Grcov report - integration

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

17

#![cfg(test)]

18

19

use {

20

    crate::{

21

        tests::common::*, xcm_config::ForeignAssetsInstance, RewardsCollatorCommission,

22

        StreamPayment, StreamPaymentAssetId, TimeUnit, TransactionPayment,

23

},

24

    cumulus_primitives_core::ParaId,

25

    dp_consensus::runtime_decl_for_tanssi_authority_assignment_api::TanssiAuthorityAssignmentApiV1,

26

    dp_core::well_known_keys,

27

    frame_support::{

28

        assert_noop, assert_ok, migration::put_storage_value, storage::generator::StorageMap,

29

        BoundedVec, Hashable,

30

},

31

    frame_system::ConsumedWeight,

32

    nimbus_primitives::NIMBUS_KEY_ID,

33

    pallet_author_noting_runtime_api::runtime_decl_for_author_noting_api::AuthorNotingApi,

34

    pallet_balances::Instance1,

35

    pallet_collator_assignment_runtime_api::runtime_decl_for_collator_assignment_api::CollatorAssignmentApi,

36

    pallet_foreign_asset_creator::{AssetIdToForeignAsset, ForeignAssetToAssetId},

37

    pallet_migrations::Migration,

38

    pallet_pooled_staking::{

39

        traits::IsCandidateEligible, AllTargetPool, EligibleCandidate, PendingOperationKey,

40

        PendingOperationQuery, PoolsKey, SharesOrStake, TargetPool,

41

},

42

    pallet_registrar_runtime_api::{

43

        runtime_decl_for_registrar_api::RegistrarApi, ContainerChainGenesisData,

44

},

45

    parity_scale_codec::Encode,

46

    rococo_runtime_constants::fee::Perbill,

47

    sp_consensus_aura::AURA_ENGINE_ID,

48

    sp_core::Get,

49

    sp_runtime::{

50

        traits::{BadOrigin, BlakeTwo256, OpaqueKeys},

51

        DigestItem, FixedU128,

52

},

53

    sp_std::vec,

54

    staging_xcm::{

55

        latest::prelude::*,

56

        v3::{

57

            Junction as V3Junction, Junctions as V3Junctions, MultiLocation as V3MultiLocation,

58

            NetworkId as V3NetworkId,

59

},

60

},

61

    std::marker::PhantomData,

62

    tanssi_runtime_common::migrations::{

63

        ForeignAssetCreatorMigration, HostConfigurationV2,

64

        MigrateConfigurationAddParachainPercentage, MigrateConfigurationParathreads,

65

        MigrateServicesPaymentAddCollatorAssignmentCredits, RegistrarPendingVerificationValueToMap,

66

},

67

    test_relay_sproof_builder::{HeaderAs, ParaHeaderSproofBuilder, ParaHeaderSproofBuilderItem},

68

    tp_traits::{ContainerChainBlockInfo, SlotFrequency},

69

};

70

71

#[test]

72

1

fn genesis_balances() {

73

1

    ExtBuilder::default()

74

1

        .with_balances(vec![

75

1

            // Alice gets 10k extra tokens for her mapping deposit

76

1

            (AccountId::from(ALICE), 210_000 * UNIT),

77

1

            (AccountId::from(BOB), 100_000 * UNIT),

78

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

79

1

            (AccountId::from(DAVE), 100_000 * UNIT),

80

1

])

81

1

        .with_collators(vec![

82

1

            // Remove ALICE and BOB from collators

83

1

            (AccountId::from(CHARLIE), 100 * UNIT),

84

1

            (AccountId::from(DAVE), 100 * UNIT),

85

1

])

86

1

        .build()

87

1

        .execute_with(|| {

88

1

            assert_eq!(

89

1

                Balances::usable_balance(AccountId::from(ALICE)),

90

1

                210_000 * UNIT,

91

1

);

92

1

            assert_eq!(

93

1

                Balances::usable_balance(AccountId::from(BOB)),

94

1

                100_000 * UNIT,

95

1

);

96

1

});

97

1

98

99

#[test]

100

1

fn genesis_para_registrar() {

101

1

    ExtBuilder::default()

102

1

        .with_empty_parachains(vec![1001, 1002])

103

1

        .build()

104

1

        .execute_with(|| {

105

1

            assert_eq!(

106

1

                Registrar::registered_para_ids(),

107

1

                vec![1001.into(), 1002.into()]

108

1

);

109

1

});

110

1

111

112

#[test]

113

1

fn genesis_para_registrar_deregister() {

114

1

    ExtBuilder::default()

115

1

        .with_empty_parachains(vec![1001, 1002])

116

1

        .build()

117

1

        .execute_with(|| {

118

1

            assert_eq!(

119

1

                Registrar::registered_para_ids(),

120

1

                vec![1001.into(), 1002.into()]

121

1

);

122

123

1

            run_to_block(2);

124

1

            assert_ok!(Registrar::deregister(root_origin(), 1002.into()), ());

125

126

            // Pending

127

1

            assert_eq!(

128

1

                Registrar::pending_registered_para_ids(),

129

1

                vec![(2u32, BoundedVec::try_from(vec![1001u32.into()]).unwrap())]

130

1

);

131

132

1

            run_to_session(1);

133

1

            assert_eq!(

134

1

                Registrar::pending_registered_para_ids(),

135

1

                vec![(2u32, BoundedVec::try_from(vec![1001u32.into()]).unwrap())]

136

1

);

137

1

            assert_eq!(

138

1

                Registrar::registered_para_ids(),

139

1

                vec![1001.into(), 1002.into()]

140

1

);

141

142

1

            run_to_session(2);

143

1

            assert_eq!(Registrar::pending_registered_para_ids(), vec![]);

144

1

            assert_eq!(Registrar::registered_para_ids(), vec![1001.into()]);

145

1

});

146

1

147

148

#[test]

149

1

fn genesis_para_registrar_runtime_api() {

150

1

    ExtBuilder::default()

151

1

        .with_empty_parachains(vec![1001, 1002])

152

1

        .build()

153

1

        .execute_with(|| {

154

1

            assert_eq!(

155

1

                Registrar::registered_para_ids(),

156

1

                vec![1001.into(), 1002.into()]

157

1

);

158

1

            assert_eq!(Runtime::registered_paras(), vec![1001.into(), 1002.into()]);

159

160

1

            run_to_block(2);

161

1

            assert_ok!(Registrar::deregister(root_origin(), 1002.into()), ());

162

1

            assert_eq!(Runtime::registered_paras(), vec![1001.into(), 1002.into()]);

163

164

1

            run_to_session(1);

165

1

            assert_eq!(

166

1

                Registrar::registered_para_ids(),

167

1

                vec![1001.into(), 1002.into()]

168

1

);

169

1

            assert_eq!(Runtime::registered_paras(), vec![1001.into(), 1002.into()]);

170

171

1

            run_to_session(2);

172

1

            assert_eq!(Registrar::registered_para_ids(), vec![1001.into()]);

173

1

            assert_eq!(Runtime::registered_paras(), vec![1001.into()]);

174

1

});

175

1

176

177

#[test]

178

1

fn genesis_para_registrar_container_chain_genesis_data_runtime_api() {

179

1

    let genesis_data_1001 = empty_genesis_data();

180

1

    let genesis_data_1002 = ContainerChainGenesisData {

181

1

        storage: vec![(b"key".to_vec(), b"value".to_vec()).into()],

182

1

        name: Default::default(),

183

1

        id: Default::default(),

184

1

        fork_id: Default::default(),

185

1

        extensions: vec![],

186

1

        properties: Default::default(),

187

1

};

188

1

    ExtBuilder::default()

189

1

        .with_para_ids(vec![

190

1

            ParaRegistrationParams {

191

1

                para_id: 1001,

192

1

                genesis_data: genesis_data_1001.clone(),

193

1

                block_production_credits: u32::MAX,

194

1

                collator_assignment_credits: u32::MAX,

195

1

                parathread_params: None,

196

1

            },ParaRegistrationParams {

197

1

                para_id: 1002,

198

1

                genesis_data: genesis_data_1002.clone(),

199

1

                block_production_credits: u32::MAX,

200

1

                collator_assignment_credits: u32::MAX,

201

1

                parathread_params: None,

202

1

},

203

1

])

204

1

        .build()

205

1

        .execute_with(|| {

206

1

            assert_eq!(

207

1

                Registrar::registered_para_ids(),

208

1

                vec![1001.into(), 1002.into()]

209

1

);

210

1

            assert_eq!(Runtime::registered_paras(), vec![1001.into(), 1002.into()]);

211

212

1

            assert_eq!(

213

1

                Runtime::genesis_data(1001.into()).as_ref(),

214

1

                Some(&genesis_data_1001)

215

1

);

216

1

            assert_eq!(

217

1

                Runtime::genesis_data(1002.into()).as_ref(),

218

1

                Some(&genesis_data_1002)

219

1

);

220

1

            assert_eq!(Runtime::genesis_data(1003.into()).as_ref(), None);

221

222

            // This API cannot be used to get the genesis data of the orchestrator chain,

223

            // with id 100

224

            // TODO: where is that 100 defined?

225

1

            assert_eq!(Runtime::genesis_data(100.into()).as_ref(), None);

226

227

1

            run_to_block(2);

228

1

            assert_ok!(Registrar::deregister(root_origin(), 1002.into()), ());

229

230

1

            assert_eq!(Runtime::genesis_data(1002.into()).as_ref(), Some(&genesis_data_1002), "Deregistered container chain genesis data should not be removed until after 2 sessions");

231

232

1

            let genesis_data_1003 = ContainerChainGenesisData {

233

1

                storage: vec![(b"key3".to_vec(), b"value3".to_vec()).into()],

234

1

                name: Default::default(),

235

1

                id: Default::default(),

236

1

                fork_id: Default::default(),

237

1

                extensions: vec![],

238

1

                properties: Default::default(),

239

1

};

240

1

            assert_ok!(

241

1

                Registrar::register(

242

1

                    origin_of(ALICE.into()),

243

1

                    1003.into(),

244

1

                    genesis_data_1003.clone(),

245

1

                    None

246

1

),

247

1

()

248

1

);

249

250

            // Registered container chains are inserted immediately

251

1

            assert_eq!(

252

1

                Runtime::genesis_data(1003.into()).as_ref(),

253

1

                Some(&genesis_data_1003)

254

1

);

255

256

            // Deregistered container chain genesis data is removed after 2 sessions

257

1

            run_to_session(2u32);

258

1

            assert_eq!(Runtime::genesis_data(1002.into()).as_ref(), None);

259

1

});

260

1

261

262

#[test]

263

1

fn test_author_collation_aura() {

264

1

    ExtBuilder::default()

265

1

        .with_empty_parachains(vec![1001, 1002])

266

1

        .build()

267

1

        .execute_with(|| {

268

1

            run_to_block(5);

269

1

            // Assert current slot gets updated

270

1

            assert_eq!(current_slot(), 4u64);

271

            // slot 4, alice

272

1

            assert!(current_author() == AccountId::from(ALICE));

273

274

1

            run_to_block(6);

275

1

276

1

            assert_eq!(current_slot(), 5u64);

277

            // slot 5, bob

278

1

            assert!(current_author() == AccountId::from(BOB));

279

1

});

280

1

281

282

#[test]

283

1

fn test_author_collation_aura_change_of_authorities_on_session() {

284

1

    ExtBuilder::default()

285

1

        .with_balances(vec![

286

1

            // Alice gets 10k extra tokens for her mapping deposit

287

1

            (AccountId::from(ALICE), 210_000 * UNIT),

288

1

            (AccountId::from(BOB), 100_000 * UNIT),

289

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

290

1

            (AccountId::from(DAVE), 100_000 * UNIT),

291

1

])

292

1

        .with_empty_parachains(vec![1001, 1002])

293

1

        .build()

294

1

        .execute_with(|| {

295

1

            run_to_block(2);

296

1

            // Assert current slot gets updated

297

1

            assert_eq!(current_slot(), 1u64);

298

1

            assert!(current_author() == AccountId::from(BOB));

299

300

            // We change invulnerables

301

            // We first need to set the keys

302

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

303

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

304

1

305

1

            let charlie_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

306

1

            let dave_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

307

1

308

1

            // Set CHARLIE and DAVE keys

309

1

            assert_ok!(Session::set_keys(

310

1

                origin_of(CHARLIE.into()),

311

1

                crate::SessionKeys {

312

1

                    nimbus: charlie_id.clone(),

313

1

},

314

1

                vec![]

315

1

));

316

1

            assert_ok!(Session::set_keys(

317

1

                origin_of(DAVE.into()),

318

1

                crate::SessionKeys {

319

1

                    nimbus: dave_id.clone(),

320

1

},

321

1

                vec![]

322

1

));

323

324

            // Change invulnerables

325

1

            assert_ok!(Invulnerables::remove_invulnerable(

326

1

                root_origin(),

327

1

                ALICE.into()

328

1

));

329

1

            assert_ok!(Invulnerables::remove_invulnerable(

330

1

                root_origin(),

331

1

                BOB.into()

332

1

));

333

1

            assert_ok!(Invulnerables::add_invulnerable(

334

1

                root_origin(),

335

1

                CHARLIE.into()

336

1

));

337

1

            assert_ok!(Invulnerables::add_invulnerable(root_origin(), DAVE.into()));

338

339

            // SESSION CHANGE. First session. it takes 2 sessions to see the change

340

1

            run_to_session(1u32);

341

1

            let author = get_orchestrator_current_author().unwrap();

342

1

343

1

            assert_eq!(current_author(), author);

344

1

            assert!(authorities() == vec![alice_id.clone(), bob_id.clone()]);

345

346

            // Invulnerables should have triggered on new session authorities change

347

1

            run_to_session(2u32);

348

1

            let author_after_changes = get_orchestrator_current_author().unwrap();

349

1

350

1

            assert_eq!(current_author(), author_after_changes);

351

1

            assert_eq!(authorities(), vec![charlie_id, dave_id]);

352

1

});

353

1

354

355

#[test]

356

1

fn test_author_collation_aura_add_assigned_to_paras() {

357

1

    ExtBuilder::default()

358

1

        .with_balances(vec![

359

1

            // Alice gets 10k extra tokens for her mapping deposit

360

1

            (AccountId::from(ALICE), 210_000 * UNIT),

361

1

            (AccountId::from(BOB), 100_000 * UNIT),

362

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

363

1

            (AccountId::from(DAVE), 100_000 * UNIT),

364

1

])

365

1

        .with_empty_parachains(vec![1001, 1002])

366

1

        .build()

367

1

        .execute_with(|| {

368

1

            run_to_block(2);

369

1

            // Assert current slot gets updated

370

1

            assert_eq!(current_slot(), 1u64);

371

1

            assert!(current_author() == AccountId::from(BOB));

372

373

            // We change invulnerables

374

            // We first need to set the keys

375

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

376

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

377

1

378

1

            let charlie_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

379

1

            let dave_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

380

1

381

1

            // Set CHARLIE and DAVE keys

382

1

            assert_ok!(Session::set_keys(

383

1

                origin_of(CHARLIE.into()),

384

1

                crate::SessionKeys { nimbus: charlie_id },

385

1

                vec![]

386

1

));

387

1

            assert_ok!(Session::set_keys(

388

1

                origin_of(DAVE.into()),

389

1

                crate::SessionKeys { nimbus: dave_id },

390

1

                vec![]

391

1

));

392

393

            // Add new invulnerables

394

1

            assert_ok!(Invulnerables::add_invulnerable(

395

1

                root_origin(),

396

1

                CHARLIE.into()

397

1

));

398

1

            assert_ok!(Invulnerables::add_invulnerable(root_origin(), DAVE.into()));

399

400

            // SESSION CHANGE. First session. it takes 2 sessions to see the change

401

1

            run_to_session(1u32);

402

1

            let author = get_orchestrator_current_author().unwrap();

403

1

404

1

            assert_eq!(current_author(), author);

405

1

            assert_eq!(authorities(), vec![alice_id.clone(), bob_id.clone()]);

406

407

            // Invulnerables should have triggered on new session authorities change

408

            // However charlie and dave shoudl have gone to one para (1001)

409

1

            run_to_session(2u32);

410

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

411

1

            let assignment = CollatorAssignment::collator_container_chain();

412

1

            assert_eq!(

413

1

                assignment.container_chains[&1001u32.into()],

414

1

                vec![CHARLIE.into(), DAVE.into()]

415

1

);

416

1

});

417

1

418

419

#[test]

420

1

fn test_authors_without_paras() {

421

1

    ExtBuilder::default()

422

1

        .with_balances(vec![

423

1

            // Alice gets 10k extra tokens for her mapping deposit

424

1

            (AccountId::from(ALICE), 210_000 * UNIT),

425

1

            (AccountId::from(BOB), 100_000 * UNIT),

426

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

427

1

            (AccountId::from(DAVE), 100_000 * UNIT),

428

1

])

429

1

        .with_collators(vec![

430

1

            (AccountId::from(ALICE), 210 * UNIT),

431

1

            (AccountId::from(BOB), 100 * UNIT),

432

1

            (AccountId::from(CHARLIE), 100 * UNIT),

433

1

            (AccountId::from(DAVE), 100 * UNIT),

434

1

])

435

1

        .build()

436

1

        .execute_with(|| {

437

1

            run_to_block(2);

438

1

            // Assert current slot gets updated

439

1

            assert_eq!(current_slot(), 1u64);

440

1

            assert!(current_author() == AccountId::from(BOB));

441

442

            // Only Alice and Bob collate for our chain

443

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

444

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

445

1

            let charlie_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

446

1

            let dave_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

447

1

448

1

            // It does not matter if we insert more collators, only two will be assigned

449

1

            assert_eq!(authorities(), vec![alice_id.clone(), bob_id.clone()]);

450

451

            // Set moondance collators to min 2 max 5

452

1

            assert_ok!(

453

1

                Configuration::set_min_orchestrator_collators(root_origin(), 2),

454

1

()

455

1

);

456

1

            assert_ok!(

457

1

                Configuration::set_max_orchestrator_collators(root_origin(), 5),

458

1

()

459

1

);

460

461

1

            run_to_session(2);

462

1

            assert_eq!(authorities(), vec![alice_id, bob_id, charlie_id, dave_id]);

463

1

});

464

1

465

466

#[test]

467

1

fn test_authors_paras_inserted_a_posteriori() {

468

1

    ExtBuilder::default()

469

1

        .with_balances(vec![

470

1

            // Alice gets 10k extra tokens for her mapping deposit

471

1

            (AccountId::from(ALICE), 210_000 * UNIT),

472

1

            (AccountId::from(BOB), 100_000 * UNIT),

473

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

474

1

            (AccountId::from(DAVE), 100_000 * UNIT),

475

1

])

476

1

        .with_collators(vec![

477

1

            (AccountId::from(ALICE), 210 * UNIT),

478

1

            (AccountId::from(BOB), 100 * UNIT),

479

1

            (AccountId::from(CHARLIE), 100 * UNIT),

480

1

            (AccountId::from(DAVE), 100 * UNIT),

481

1

])

482

1

        .build()

483

1

        .execute_with(|| {

484

1

            run_to_block(2);

485

1

            // Assert current slot gets updated

486

1

            assert_eq!(current_slot(), 1u64);

487

1

            assert!(current_author() == AccountId::from(BOB));

488

489

            // Alice and Bob collate in our chain

490

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

491

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

492

1

493

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

494

495

1

            assert_ok!(Registrar::register(

496

1

                origin_of(ALICE.into()),

497

1

                1001.into(),

498

1

                empty_genesis_data(),

499

1

                None

500

1

));

501

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

502

1

            assert_ok!(Registrar::mark_valid_for_collating(

503

1

                root_origin(),

504

1

                1001.into()

505

1

));

506

1

            assert_ok!(ServicesPayment::purchase_credits(

507

1

                origin_of(ALICE.into()),

508

1

                1001.into(),

509

1

                block_credits_to_required_balance(1000, 1001.into())

510

1

));

511

1

            assert_ok!(Registrar::register(

512

1

                origin_of(ALICE.into()),

513

1

                1002.into(),

514

1

                empty_genesis_data(),

515

1

                None

516

1

));

517

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1002.into());

518

1

            assert_ok!(Registrar::mark_valid_for_collating(

519

1

                root_origin(),

520

1

                1002.into()

521

1

));

522

1

            assert_ok!(ServicesPayment::purchase_credits(

523

1

                origin_of(ALICE.into()),

524

1

                1002.into(),

525

1

                block_credits_to_required_balance(1000, 1002.into())

526

1

));

527

528

            // Assignment should happen after 2 sessions

529

1

            run_to_session(1u32);

530

1

            let assignment = CollatorAssignment::collator_container_chain();

531

1

            assert!(assignment.container_chains.is_empty());

532

1

            run_to_session(2u32);

533

1

534

1

            // Charlie and Dave should be assigned to para 1001

535

1

            let assignment = CollatorAssignment::collator_container_chain();

536

1

            assert_eq!(

537

1

                assignment.container_chains[&1001u32.into()],

538

1

                vec![CHARLIE.into(), DAVE.into()]

539

1

);

540

1

});

541

1

542

543

#[test]

544

1

fn test_authors_paras_inserted_a_posteriori_with_collators_already_assigned() {

545

1

    ExtBuilder::default()

546

1

        .with_balances(vec![

547

1

            // Alice gets 10k extra tokens for her mapping deposit

548

1

            (AccountId::from(ALICE), 210_000 * UNIT),

549

1

            (AccountId::from(BOB), 100_000 * UNIT),

550

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

551

1

            (AccountId::from(DAVE), 100_000 * UNIT),

552

1

])

553

1

        .with_collators(vec![

554

1

            (AccountId::from(ALICE), 210 * UNIT),

555

1

            (AccountId::from(BOB), 100 * UNIT),

556

1

            (AccountId::from(CHARLIE), 100 * UNIT),

557

1

            (AccountId::from(DAVE), 100 * UNIT),

558

1

])

559

1

        .with_config(pallet_configuration::HostConfiguration {

560

1

            max_collators: 100,

561

1

            min_orchestrator_collators: 2,

562

1

            max_orchestrator_collators: 5,

563

1

            collators_per_container: 2,

564

1

            full_rotation_period: 24,

565

1

            ..Default::default()

566

1

})

567

1

        .build()

568

1

        .execute_with(|| {

569

1

            run_to_block(2);

570

1

            // Assert current slot gets updated

571

1

            assert_eq!(current_slot(), 1u64);

572

1

            assert!(current_author() == AccountId::from(BOB));

573

574

            // Alice and Bob collate in our chain

575

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

576

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

577

1

            let charlie_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

578

1

            let dave_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

579

1

580

1

            assert_eq!(authorities(), vec![alice_id, bob_id, charlie_id, dave_id]);

581

582

1

            assert_ok!(Registrar::register(

583

1

                origin_of(ALICE.into()),

584

1

                1001.into(),

585

1

                empty_genesis_data(),

586

1

                None

587

1

));

588

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

589

1

            assert_ok!(Registrar::mark_valid_for_collating(

590

1

                root_origin(),

591

1

                1001.into()

592

1

));

593

1

            assert_ok!(ServicesPayment::purchase_credits(

594

1

                origin_of(ALICE.into()),

595

1

                1001.into(),

596

1

                block_credits_to_required_balance(1000, 1001.into())

597

1

));

598

599

            // Assignment should happen after 2 sessions

600

1

            run_to_session(1u32);

601

1

            let assignment = CollatorAssignment::collator_container_chain();

602

1

            assert!(assignment.container_chains.is_empty());

603

1

            run_to_session(2u32);

604

1

605

1

            // Charlie and Dave are now assigned to para 1001

606

1

            let assignment = CollatorAssignment::collator_container_chain();

607

1

            assert_eq!(

608

1

                assignment.container_chains[&1001u32.into()],

609

1

                vec![CHARLIE.into(), DAVE.into()]

610

1

);

611

1

            assert_eq!(

612

1

                assignment.orchestrator_chain,

613

1

                vec![ALICE.into(), BOB.into()]

614

1

);

615

1

});

616

1

617

618

#[test]

619

1

fn test_paras_registered_but_zero_credits() {

620

1

    ExtBuilder::default()

621

1

        .with_balances(vec![

622

1

            // Alice gets 10k extra tokens for her mapping deposit

623

1

            (AccountId::from(ALICE), 210_000 * UNIT),

624

1

            (AccountId::from(BOB), 100_000 * UNIT),

625

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

626

1

            (AccountId::from(DAVE), 100_000 * UNIT),

627

1

])

628

1

        .with_collators(vec![

629

1

            (AccountId::from(ALICE), 210 * UNIT),

630

1

            (AccountId::from(BOB), 100 * UNIT),

631

1

            (AccountId::from(CHARLIE), 100 * UNIT),

632

1

            (AccountId::from(DAVE), 100 * UNIT),

633

1

])

634

1

        .build()

635

1

        .execute_with(|| {

636

1

            run_to_block(2);

637

1

            // Assert current slot gets updated

638

1

            assert_eq!(current_slot(), 1u64);

639

1

            assert!(current_author() == AccountId::from(BOB));

640

641

            // Alice and Bob collate in our chain

642

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

643

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

644

1

645

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

646

647

1

            assert_ok!(Registrar::register(

648

1

                origin_of(ALICE.into()),

649

1

                1001.into(),

650

1

                empty_genesis_data(),

651

1

                None

652

1

));

653

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

654

1

            assert_ok!(Registrar::mark_valid_for_collating(

655

1

                root_origin(),

656

1

                1001.into()

657

1

));

658

            // Need to reset credits to 0 because now parachains are given free credits on register

659

1

            assert_ok!(ServicesPayment::set_block_production_credits(

660

1

                root_origin(),

661

1

                1001.into(),

662

1

663

1

));

664

665

            // Assignment should happen after 2 sessions

666

1

            run_to_session(1u32);

667

1

            let assignment = CollatorAssignment::collator_container_chain();

668

1

            assert!(assignment.container_chains.is_empty());

669

1

            run_to_session(2u32);

670

1

671

1

            // Nobody should be assigned to para 1001

672

1

            let assignment = CollatorAssignment::collator_container_chain();

673

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

674

1

});

675

1

676

677

#[test]

678

1

fn test_paras_registered_but_not_enough_credits() {

679

1

    ExtBuilder::default()

680

1

        .with_balances(vec![

681

1

            // Alice gets 10k extra tokens for her mapping deposit

682

1

            (AccountId::from(ALICE), 210_000 * UNIT),

683

1

            (AccountId::from(BOB), 100_000 * UNIT),

684

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

685

1

            (AccountId::from(DAVE), 100_000 * UNIT),

686

1

])

687

1

        .with_collators(vec![

688

1

            (AccountId::from(ALICE), 210 * UNIT),

689

1

            (AccountId::from(BOB), 100 * UNIT),

690

1

            (AccountId::from(CHARLIE), 100 * UNIT),

691

1

            (AccountId::from(DAVE), 100 * UNIT),

692

1

])

693

1

        .build()

694

1

        .execute_with(|| {

695

1

            run_to_block(2);

696

1

            // Assert current slot gets updated

697

1

            assert_eq!(current_slot(), 1u64);

698

1

            assert!(current_author() == AccountId::from(BOB));

699

700

            // Alice and Bob collate in our chain

701

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

702

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

703

1

704

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

705

706

1

            assert_ok!(Registrar::register(

707

1

                origin_of(ALICE.into()),

708

1

                1001.into(),

709

1

                empty_genesis_data(),

710

1

                None

711

1

));

712

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

713

1

            assert_ok!(Registrar::mark_valid_for_collating(

714

1

                root_origin(),

715

1

                1001.into()

716

1

));

717

            // Need to reset credits to 0 because now parachains are given free credits on register

718

1

            assert_ok!(ServicesPayment::set_block_production_credits(

719

1

                root_origin(),

720

1

                1001.into(),

721

1

722

1

));

723

            // Purchase 1 credit less that what is needed

724

1

            let credits_1001 = crate::Period::get() - 1;

725

1

            assert_ok!(ServicesPayment::set_block_production_credits(

726

1

                root_origin(),

727

1

                1001.into(),

728

1

                credits_1001

729

1

));

730

731

            // Assignment should happen after 2 sessions

732

1

            run_to_session(1u32);

733

1

            let assignment = CollatorAssignment::collator_container_chain();

734

1

            assert!(assignment.container_chains.is_empty());

735

1

            run_to_session(2u32);

736

1

            // Nobody should be assigned to para 1001

737

1

            let assignment = CollatorAssignment::collator_container_chain();

738

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None);

739

740

            // Now purchase the missing block credit

741

1

            assert_ok!(ServicesPayment::set_block_production_credits(

742

1

                root_origin(),

743

1

                1001.into(),

744

1

                credits_1001 + 1

745

1

));

746

747

1

            run_to_session(4u32);

748

1

            // Charlie and Dave should be assigned to para 1001

749

1

            let assignment = CollatorAssignment::collator_container_chain();

750

1

            assert_eq!(

751

1

                assignment.container_chains[&1001u32.into()],

752

1

                vec![CHARLIE.into(), DAVE.into()]

753

1

);

754

1

});

755

1

756

757

#[test]

758

1

fn test_paras_registered_but_only_credits_for_1_session() {

759

1

    ExtBuilder::default()

760

1

        .with_balances(vec![

761

1

            // Alice gets 10k extra tokens for her mapping deposit

762

1

            (AccountId::from(ALICE), 210_000 * UNIT),

763

1

            (AccountId::from(BOB), 100_000 * UNIT),

764

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

765

1

            (AccountId::from(DAVE), 100_000 * UNIT),

766

1

])

767

1

        .with_collators(vec![

768

1

            (AccountId::from(ALICE), 210 * UNIT),

769

1

            (AccountId::from(BOB), 100 * UNIT),

770

1

            (AccountId::from(CHARLIE), 100 * UNIT),

771

1

            (AccountId::from(DAVE), 100 * UNIT),

772

1

])

773

1

        .build()

774

1

        .execute_with(|| {

775

1

            run_to_block(2);

776

1

            // Assert current slot gets updated

777

1

            assert_eq!(current_slot(), 1u64);

778

1

            assert!(current_author() == AccountId::from(BOB));

779

780

            // Alice and Bob collate in our chain

781

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

782

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

783

1

784

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

785

786

1

            assert_ok!(Registrar::register(

787

1

                origin_of(ALICE.into()),

788

1

                1001.into(),

789

1

                empty_genesis_data(),

790

1

                None

791

1

));

792

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

793

1

            assert_ok!(Registrar::mark_valid_for_collating(

794

1

                root_origin(),

795

1

                1001.into()

796

1

));

797

            // Need to reset credits to 0 because now parachains are given free credits on register

798

1

            assert_ok!(ServicesPayment::set_block_production_credits(

799

1

                root_origin(),

800

1

                1001.into(),

801

1

802

1

));

803

            // Purchase only enough credits for 1 session

804

1

            let credits_1001 = crate::Period::get();

805

1

            assert_ok!(ServicesPayment::set_block_production_credits(

806

1

                root_origin(),

807

1

                1001.into(),

808

1

                credits_1001

809

1

));

810

811

            // Assignment should happen after 2 sessions

812

1

            run_to_session(1u32);

813

1

            let assignment = CollatorAssignment::collator_container_chain();

814

1

            assert!(assignment.container_chains.is_empty());

815

1

            run_to_session(2u32);

816

1

            // Charlie and Dave should be assigned to para 1001

817

1

            let assignment = CollatorAssignment::collator_container_chain();

818

1

            assert_eq!(

819

1

                assignment.container_chains[&1001u32.into()],

820

1

                vec![CHARLIE.into(), DAVE.into()]

821

1

);

822

823

            // No credits are consumed if the container chain is not producing blocks

824

1

            run_block();

825

1

            let credits =

826

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

827

1

                    .unwrap_or_default();

828

1

            assert_eq!(credits, credits_1001);

829

830

            // Simulate block inclusion from container chain 1001

831

1

            let mut sproof = ParaHeaderSproofBuilder::default();

832

1

            let slot: u64 = 5;

833

1

            let s = ParaHeaderSproofBuilderItem {

834

1

                para_id: 1001.into(),

835

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

836

1

                    parent_hash: Default::default(),

837

1

                    number: 1,

838

1

                    state_root: Default::default(),

839

1

                    extrinsics_root: Default::default(),

840

1

                    digest: sp_runtime::generic::Digest {

841

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

842

1

},

843

1

}),

844

1

};

845

1

            sproof.items.push(s);

846

1

            set_author_noting_inherent_data(sproof);

847

1

848

1

            run_block();

849

1

            let credits =

850

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

851

1

                    .unwrap_or_default();

852

1

            assert_eq!(credits, credits_1001 - 1);

853

854

1

            run_to_session(4u32);

855

1

            // Nobody should be assigned to para 1001

856

1

            let assignment = CollatorAssignment::collator_container_chain();

857

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

858

859

            // The container chain only produced one block, so it only consumed one block credit.

860

            // (it could have produced more blocks, but at most it would have consumed `Period::get()` credits)

861

1

            let credits =

862

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

863

1

                    .unwrap_or_default();

864

1

            assert_eq!(credits, credits_1001 - 1);

865

1

});

866

1

867

868

#[test]

869

1

fn test_parachains_deregister_collators_re_assigned() {

870

1

    ExtBuilder::default()

871

1

        .with_balances(vec![

872

1

            // Alice gets 10k extra tokens for her mapping deposit

873

1

            (AccountId::from(ALICE), 210_000 * UNIT),

874

1

            (AccountId::from(BOB), 100_000 * UNIT),

875

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

876

1

            (AccountId::from(DAVE), 100_000 * UNIT),

877

1

])

878

1

        .with_collators(vec![

879

1

            (AccountId::from(ALICE), 210 * UNIT),

880

1

            (AccountId::from(BOB), 100 * UNIT),

881

1

            (AccountId::from(CHARLIE), 100 * UNIT),

882

1

            (AccountId::from(DAVE), 100 * UNIT),

883

1

])

884

1

        .with_empty_parachains(vec![1001, 1002])

885

1

        .build()

886

1

        .execute_with(|| {

887

1

            run_to_block(2);

888

1

            // Assert current slot gets updated

889

1

            assert_eq!(current_slot(), 1u64);

890

1

            assert!(current_author() == AccountId::from(BOB));

891

892

            // Alice and Bob are authorities

893

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

894

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

895

1

896

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

897

898

            // Charlie and Dave to 1001

899

1

            let assignment = CollatorAssignment::collator_container_chain();

900

1

            assert_eq!(

901

1

                assignment.container_chains[&1001u32.into()],

902

1

                vec![CHARLIE.into(), DAVE.into()]

903

1

);

904

905

1

            assert_ok!(Registrar::deregister(root_origin(), 1001.into()), ());

906

907

            // Assignment should happen after 2 sessions

908

1

            run_to_session(1u32);

909

1

910

1

            let assignment = CollatorAssignment::collator_container_chain();

911

1

            assert_eq!(

912

1

                assignment.container_chains[&1001u32.into()],

913

1

                vec![CHARLIE.into(), DAVE.into()]

914

1

);

915

916

1

            run_to_session(2u32);

917

1

918

1

            // Charlie and Dave should be assigne dot para 1002 this time

919

1

            let assignment = CollatorAssignment::collator_container_chain();

920

1

            assert_eq!(

921

1

                assignment.container_chains[&1002u32.into()],

922

1

                vec![CHARLIE.into(), DAVE.into()]

923

1

);

924

1

});

925

1

926

927

#[test]

928

1

fn test_parachains_deregister_collators_config_change_reassigned() {

929

1

    ExtBuilder::default()

930

1

        .with_balances(vec![

931

1

            // Alice gets 10k extra tokens for her mapping deposit

932

1

            (AccountId::from(ALICE), 210_000 * UNIT),

933

1

            (AccountId::from(BOB), 100_000 * UNIT),

934

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

935

1

            (AccountId::from(DAVE), 100_000 * UNIT),

936

1

])

937

1

        .with_collators(vec![

938

1

            (AccountId::from(ALICE), 210 * UNIT),

939

1

            (AccountId::from(BOB), 100 * UNIT),

940

1

            (AccountId::from(CHARLIE), 100 * UNIT),

941

1

            (AccountId::from(DAVE), 100 * UNIT),

942

1

])

943

1

        .with_empty_parachains(vec![1001, 1002])

944

1

        .build()

945

1

        .execute_with(|| {

946

1

            run_to_block(2);

947

1

            // Assert current slot gets updated

948

1

            assert_eq!(current_slot(), 1u64);

949

1

            assert!(current_author() == AccountId::from(BOB));

950

951

            // Alice and Bob are authorities

952

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

953

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

954

1

955

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

956

957

            // Set orchestrator collators to 1

958

1

            assert_ok!(

959

1

                Configuration::set_max_orchestrator_collators(root_origin(), 1),

960

1

()

961

1

);

962

963

            // Set container chain collators to 3

964

1

            assert_ok!(

965

1

                Configuration::set_collators_per_container(root_origin(), 3),

966

1

()

967

1

);

968

969

            // Charlie and Dave to 1001

970

1

            let assignment = CollatorAssignment::collator_container_chain();

971

1

            assert_eq!(

972

1

                assignment.container_chains[&1001u32.into()],

973

1

                vec![CHARLIE.into(), DAVE.into()]

974

1

);

975

976

            // Assignment should happen after 2 sessions

977

1

            run_to_session(1u32);

978

1

979

1

            let assignment = CollatorAssignment::collator_container_chain();

980

1

            assert_eq!(

981

1

                assignment.container_chains[&1001u32.into()],

982

1

                vec![CHARLIE.into(), DAVE.into()]

983

1

);

984

985

1

            run_to_session(2u32);

986

1

987

1

            // Charlie, Dave and BOB should be assigne dot para 1001 this time

988

1

            let assignment = CollatorAssignment::collator_container_chain();

989

1

            assert_eq!(

990

1

                assignment.container_chains[&1001u32.into()],

991

1

                vec![CHARLIE.into(), DAVE.into(), BOB.into()]

992

1

);

993

994

1

            assert_eq!(assignment.orchestrator_chain, vec![ALICE.into()]);

995

1

});

996

1

997

998

#[test]

999

1

fn test_orchestrator_collators_with_non_sufficient_collators() {

1000

1

    ExtBuilder::default()

1001

1

        .with_balances(vec![

1002

1

            // Alice gets 10k extra tokens for her mapping deposit

1003

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1004

1

])

1005

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

1006

1

        .with_empty_parachains(vec![1001, 1002])

1007

1

        .build()

1008

1

        .execute_with(|| {

1009

1

            run_to_block(2);

1010

1

            // Assert current slot gets updated

1011

1

            assert_eq!(current_slot(), 1u64);

1012

1

            assert!(current_author() == AccountId::from(ALICE));

1013

1014

            // Alice and Bob are authorities

1015

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

1016

1

1017

1

            assert_eq!(authorities(), vec![alice_id]);

1018

1

});

1019

1

1020

1021

#[test]

1022

1

fn test_configuration_on_session_change() {

1023

1

    ExtBuilder::default().build().execute_with(|| {

1024

1

        assert_eq!(Configuration::config().max_collators, 100);

1025

1

        assert_eq!(Configuration::config().min_orchestrator_collators, 2);

1026

1

        assert_eq!(Configuration::config().collators_per_container, 2);

1027

1028

1

        assert_ok!(Configuration::set_max_collators(root_origin(), 50), ());

1029

1

        run_to_session(1u32);

1030

1

1031

1

        assert_ok!(

1032

1

            Configuration::set_min_orchestrator_collators(root_origin(), 20),

1033

1

()

1034

1

);

1035

1

        assert_eq!(Configuration::config().max_collators, 100);

1036

1

        assert_eq!(Configuration::config().min_orchestrator_collators, 2);

1037

1

        assert_eq!(Configuration::config().collators_per_container, 2);

1038

1039

1

        run_to_session(2u32);

1040

1

        assert_ok!(

1041

1

            Configuration::set_collators_per_container(root_origin(), 10),

1042

1

()

1043

1

);

1044

1

        assert_eq!(Configuration::config().max_collators, 50);

1045

1

        assert_eq!(Configuration::config().min_orchestrator_collators, 2);

1046

1

        assert_eq!(Configuration::config().collators_per_container, 2);

1047

1048

1

        run_to_session(3u32);

1049

1

1050

1

        assert_eq!(Configuration::config().max_collators, 50);

1051

1

        assert_eq!(Configuration::config().min_orchestrator_collators, 20);

1052

1

        assert_eq!(Configuration::config().collators_per_container, 2);

1053

1054

1

        run_to_session(4u32);

1055

1

1056

1

        assert_eq!(Configuration::config().max_collators, 50);

1057

1

        assert_eq!(Configuration::config().min_orchestrator_collators, 20);

1058

1

        assert_eq!(Configuration::config().collators_per_container, 10);

1059

1

});

1060

1

1061

1062

#[test]

1063

1

fn test_author_collation_aura_add_assigned_to_paras_runtime_api() {

1064

1

    ExtBuilder::default()

1065

1

        .with_balances(vec![

1066

1

            // Alice gets 10k extra tokens for her mapping deposit

1067

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1068

1

            (AccountId::from(BOB), 100_000 * UNIT),

1069

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1070

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1071

1

])

1072

1

        .with_empty_parachains(vec![1001, 1002])

1073

1

        .build()

1074

1

        .execute_with(|| {

1075

1

            run_to_block(2);

1076

1

            // Assert current slot gets updated

1077

1

            assert_eq!(current_slot(), 1u64);

1078

1

            assert!(current_author() == AccountId::from(BOB));

1079

1

            assert_eq!(

1080

1

                Runtime::parachain_collators(100.into()),

1081

1

                Some(vec![ALICE.into(), BOB.into()])

1082

1

);

1083

1

            assert_eq!(Runtime::parachain_collators(1001.into()), Some(vec![]));

1084

1

            assert_eq!(

1085

1

                Runtime::current_collator_parachain_assignment(ALICE.into()),

1086

1

                Some(100.into())

1087

1

);

1088

1

            assert_eq!(

1089

1

                Runtime::future_collator_parachain_assignment(ALICE.into()),

1090

1

                Some(100.into())

1091

1

);

1092

1

            assert_eq!(

1093

1

                Runtime::current_collator_parachain_assignment(CHARLIE.into()),

1094

1

                None

1095

1

);

1096

1

            assert_eq!(

1097

1

                Runtime::future_collator_parachain_assignment(CHARLIE.into()),

1098

1

                None

1099

1

);

1100

1101

            // We change invulnerables

1102

            // We first need to set the keys

1103

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

1104

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

1105

1

1106

1

            let charlie_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

1107

1

            let dave_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

1108

1

1109

1

            // Set CHARLIE and DAVE keys

1110

1

            assert_ok!(Session::set_keys(

1111

1

                origin_of(CHARLIE.into()),

1112

1

                crate::SessionKeys { nimbus: charlie_id },

1113

1

                vec![]

1114

1

));

1115

1

            assert_ok!(Session::set_keys(

1116

1

                origin_of(DAVE.into()),

1117

1

                crate::SessionKeys { nimbus: dave_id },

1118

1

                vec![]

1119

1

));

1120

1121

            // Set new invulnerables

1122

1

            assert_ok!(Invulnerables::add_invulnerable(

1123

1

                root_origin(),

1124

1

                CHARLIE.into()

1125

1

));

1126

1

            assert_ok!(Invulnerables::add_invulnerable(root_origin(), DAVE.into()));

1127

1128

            // SESSION CHANGE. First session. it takes 2 sessions to see the change

1129

1

            run_to_session(1u32);

1130

1

            let author = get_orchestrator_current_author().unwrap();

1131

1

1132

1

            assert_eq!(current_author(), author);

1133

1

            assert_eq!(authorities(), vec![alice_id.clone(), bob_id.clone()]);

1134

1

            assert_eq!(

1135

1

                Runtime::parachain_collators(100.into()),

1136

1

                Some(vec![ALICE.into(), BOB.into()])

1137

1

);

1138

1

            assert_eq!(Runtime::parachain_collators(1001.into()), Some(vec![]));

1139

1

            assert_eq!(

1140

1

                Runtime::current_collator_parachain_assignment(CHARLIE.into()),

1141

1

                None

1142

1

);

1143

1

            assert_eq!(

1144

1

                Runtime::future_collator_parachain_assignment(CHARLIE.into()),

1145

1

                Some(1001.into())

1146

1

);

1147

1148

            // Invulnerables should have triggered on new session authorities change

1149

            // However charlie and dave shoudl have gone to one para (1001)

1150

1

            run_to_session(2u32);

1151

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

1152

1

            let assignment = CollatorAssignment::collator_container_chain();

1153

1

            assert_eq!(

1154

1

                assignment.container_chains[&1001u32.into()],

1155

1

                vec![CHARLIE.into(), DAVE.into()]

1156

1

);

1157

1158

1

            assert_eq!(

1159

1

                Runtime::parachain_collators(100.into()),

1160

1

                Some(vec![ALICE.into(), BOB.into()])

1161

1

);

1162

1

            assert_eq!(

1163

1

                Runtime::parachain_collators(1001.into()),

1164

1

                Some(vec![CHARLIE.into(), DAVE.into()])

1165

1

);

1166

1

            assert_eq!(

1167

1

                Runtime::current_collator_parachain_assignment(CHARLIE.into()),

1168

1

                Some(1001.into())

1169

1

);

1170

1

            assert_eq!(

1171

1

                Runtime::future_collator_parachain_assignment(CHARLIE.into()),

1172

1

                Some(1001.into())

1173

1

);

1174

1175

            // Remove BOB

1176

1

            assert_ok!(Invulnerables::remove_invulnerable(

1177

1

                root_origin(),

1178

1

                BOB.into()

1179

1

));

1180

1181

1

            run_to_session(3u32);

1182

1

            assert_eq!(

1183

1

                Runtime::parachain_collators(100.into()),

1184

1

                Some(vec![ALICE.into(), BOB.into()])

1185

1

);

1186

1

            assert_eq!(

1187

1

                Runtime::parachain_collators(1001.into()),

1188

1

                Some(vec![CHARLIE.into(), DAVE.into()])

1189

1

);

1190

1

            assert_eq!(

1191

1

                Runtime::current_collator_parachain_assignment(BOB.into()),

1192

1

                Some(100.into())

1193

1

);

1194

1

            assert_eq!(

1195

1

                Runtime::future_collator_parachain_assignment(BOB.into()),

1196

1

                None

1197

1

);

1198

1199

1

            run_to_session(4u32);

1200

1

            assert_eq!(

1201

1

                Runtime::parachain_collators(100.into()),

1202

1

                Some(vec![ALICE.into(), CHARLIE.into()])

1203

1

);

1204

1

            assert_eq!(Runtime::parachain_collators(1001.into()), Some(vec![]));

1205

1

            assert_eq!(

1206

1

                Runtime::current_collator_parachain_assignment(BOB.into()),

1207

1

                None

1208

1

);

1209

1

            assert_eq!(

1210

1

                Runtime::future_collator_parachain_assignment(BOB.into()),

1211

1

                None

1212

1

);

1213

1

});

1214

1

1215

1216

#[test]

1217

1

fn test_consensus_runtime_api() {

1218

1

    ExtBuilder::default()

1219

1

        .with_balances(vec![

1220

1

            // Alice gets 10k extra tokens for her mapping deposit

1221

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1222

1

            (AccountId::from(BOB), 100_000 * UNIT),

1223

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1224

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1225

1

])

1226

1

        .with_empty_parachains(vec![1001, 1002])

1227

1

        .build()

1228

1

        .execute_with(|| {

1229

1

            run_to_block(2);

1230

1

1231

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

1232

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

1233

1

1234

1

            let charlie_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

1235

1

            let dave_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

1236

1

1237

1

            assert_eq!(

1238

1

                Runtime::para_id_authorities(100.into()),

1239

1

                Some(vec![alice_id.clone(), bob_id.clone()])

1240

1

);

1241

1

            assert_eq!(Runtime::para_id_authorities(1001.into()), Some(vec![]));

1242

1

            assert_eq!(

1243

1

                Runtime::check_para_id_assignment(alice_id.clone()),

1244

1

                Some(100.into())

1245

1

);

1246

1

            assert_eq!(

1247

1

                Runtime::check_para_id_assignment(bob_id.clone()),

1248

1

                Some(100.into())

1249

1

);

1250

1

            assert_eq!(Runtime::check_para_id_assignment(charlie_id.clone()), None);

1251

1

            assert_eq!(Runtime::check_para_id_assignment(dave_id.clone()), None);

1252

1253

            // Set CHARLIE and DAVE keys

1254

1

            assert_ok!(Session::set_keys(

1255

1

                origin_of(CHARLIE.into()),

1256

1

                crate::SessionKeys {

1257

1

                    nimbus: charlie_id.clone(),

1258

1

},

1259

1

                vec![]

1260

1

));

1261

1

            assert_ok!(Session::set_keys(

1262

1

                origin_of(DAVE.into()),

1263

1

                crate::SessionKeys {

1264

1

                    nimbus: dave_id.clone(),

1265

1

},

1266

1

                vec![]

1267

1

));

1268

1269

            // Set new invulnerables

1270

1

            assert_ok!(Invulnerables::add_invulnerable(

1271

1

                root_origin(),

1272

1

                CHARLIE.into()

1273

1

));

1274

1

            assert_ok!(Invulnerables::add_invulnerable(root_origin(), DAVE.into()));

1275

1276

1

            run_to_session(2u32);

1277

1

            assert_eq!(

1278

1

                Runtime::para_id_authorities(100.into()),

1279

1

                Some(vec![alice_id.clone(), bob_id.clone()])

1280

1

);

1281

1

            assert_eq!(

1282

1

                Runtime::para_id_authorities(1001.into()),

1283

1

                Some(vec![charlie_id.clone(), dave_id.clone()])

1284

1

);

1285

1

            assert_eq!(

1286

1

                Runtime::check_para_id_assignment(alice_id),

1287

1

                Some(100.into())

1288

1

);

1289

1

            assert_eq!(Runtime::check_para_id_assignment(bob_id), Some(100.into()));

1290

1

            assert_eq!(

1291

1

                Runtime::check_para_id_assignment(charlie_id),

1292

1

                Some(1001.into())

1293

1

);

1294

1

            assert_eq!(

1295

1

                Runtime::check_para_id_assignment(dave_id),

1296

1

                Some(1001.into())

1297

1

);

1298

1

});

1299

1

1300

1301

#[test]

1302

1

fn test_consensus_runtime_api_session_changes() {

1303

1

    // The test shoul return always the assiignment on the next epoch

1304

1

    // Meaning that we need to see before the session change block

1305

1

    // if we can predict correctly

1306

1

    ExtBuilder::default()

1307

1

        .with_balances(vec![

1308

1

            // Alice gets 10k extra tokens for her mapping deposit

1309

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1310

1

            (AccountId::from(BOB), 100_000 * UNIT),

1311

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1312

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1313

1

])

1314

1

        .with_empty_parachains(vec![1001, 1002])

1315

1

        .build()

1316

1

        .execute_with(|| {

1317

1

            run_to_block(2);

1318

1

1319

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

1320

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

1321

1

1322

1

            let charlie_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

1323

1

            let dave_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

1324

1

1325

1

            assert_eq!(

1326

1

                Runtime::para_id_authorities(100.into()),

1327

1

                Some(vec![alice_id.clone(), bob_id.clone()])

1328

1

);

1329

1

            assert_eq!(Runtime::para_id_authorities(1001.into()), Some(vec![]));

1330

1

            assert_eq!(

1331

1

                Runtime::check_para_id_assignment(alice_id.clone()),

1332

1

                Some(100.into())

1333

1

);

1334

1

            assert_eq!(

1335

1

                Runtime::check_para_id_assignment(bob_id.clone()),

1336

1

                Some(100.into())

1337

1

);

1338

1

            assert_eq!(Runtime::check_para_id_assignment(charlie_id.clone()), None);

1339

1

            assert_eq!(Runtime::check_para_id_assignment(dave_id.clone()), None);

1340

1341

            // Set CHARLIE and DAVE keys

1342

1

            assert_ok!(Session::set_keys(

1343

1

                origin_of(CHARLIE.into()),

1344

1

                crate::SessionKeys {

1345

1

                    nimbus: charlie_id.clone(),

1346

1

},

1347

1

                vec![]

1348

1

));

1349

1

            assert_ok!(Session::set_keys(

1350

1

                origin_of(DAVE.into()),

1351

1

                crate::SessionKeys {

1352

1

                    nimbus: dave_id.clone(),

1353

1

},

1354

1

                vec![]

1355

1

));

1356

1357

            // Set new invulnerables

1358

1

            assert_ok!(Invulnerables::add_invulnerable(

1359

1

                root_origin(),

1360

1

                CHARLIE.into()

1361

1

));

1362

1

            assert_ok!(Invulnerables::add_invulnerable(root_origin(), DAVE.into()));

1363

1364

1

            let session_two_edge = crate::Period::get() * 2;

1365

1

            // Let's run just 2 blocks before the session 2 change first

1366

1

            // Prediction should still be identical, as we are not in the

1367

1

            // edge of a session change

1368

1

            run_to_block(session_two_edge - 2);

1369

1

1370

1

            assert_eq!(

1371

1

                Runtime::para_id_authorities(100.into()),

1372

1

                Some(vec![alice_id.clone(), bob_id.clone()])

1373

1

);

1374

1

            assert_eq!(Runtime::para_id_authorities(1001.into()), Some(vec![]));

1375

1

            assert_eq!(

1376

1

                Runtime::check_para_id_assignment(alice_id.clone()),

1377

1

                Some(100.into())

1378

1

);

1379

1

            assert_eq!(

1380

1

                Runtime::check_para_id_assignment(bob_id.clone()),

1381

1

                Some(100.into())

1382

1

);

1383

1

            assert_eq!(Runtime::check_para_id_assignment(charlie_id.clone()), None);

1384

1

            assert_eq!(Runtime::check_para_id_assignment(dave_id.clone()), None);

1385

1386

            // Now we run to session edge -1. Here we should predict already with

1387

            // authorities of the next block!

1388

1

            run_to_block(session_two_edge - 1);

1389

1

            assert_eq!(

1390

1

                Runtime::para_id_authorities(100.into()),

1391

1

                Some(vec![alice_id.clone(), bob_id.clone()])

1392

1

);

1393

1

            assert_eq!(

1394

1

                Runtime::para_id_authorities(1001.into()),

1395

1

                Some(vec![charlie_id.clone(), dave_id.clone()])

1396

1

);

1397

1

            assert_eq!(

1398

1

                Runtime::check_para_id_assignment(alice_id),

1399

1

                Some(100.into())

1400

1

);

1401

1

            assert_eq!(Runtime::check_para_id_assignment(bob_id), Some(100.into()));

1402

1

            assert_eq!(

1403

1

                Runtime::check_para_id_assignment(charlie_id),

1404

1

                Some(1001.into())

1405

1

);

1406

1

            assert_eq!(

1407

1

                Runtime::check_para_id_assignment(dave_id),

1408

1

                Some(1001.into())

1409

1

);

1410

1

});

1411

1

1412

1413

#[test]

1414

1

fn test_consensus_runtime_api_next_session() {

1415

1

    ExtBuilder::default()

1416

1

        .with_balances(vec![

1417

1

            // Alice gets 10k extra tokens for her mapping deposit

1418

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1419

1

            (AccountId::from(BOB), 100_000 * UNIT),

1420

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1421

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1422

1

])

1423

1

        .with_empty_parachains(vec![1001, 1002])

1424

1

        .build()

1425

1

        .execute_with(|| {

1426

1

            run_to_block(2);

1427

1

1428

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

1429

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

1430

1

1431

1

            let charlie_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

1432

1

            let dave_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

1433

1

1434

1

            assert_eq!(

1435

1

                Runtime::para_id_authorities(100.into()),

1436

1

                Some(vec![alice_id.clone(), bob_id.clone()])

1437

1

);

1438

1

            assert_eq!(Runtime::para_id_authorities(1001.into()), Some(vec![]));

1439

1

            assert_eq!(

1440

1

                Runtime::check_para_id_assignment(alice_id.clone()),

1441

1

                Some(100.into())

1442

1

);

1443

1

            assert_eq!(

1444

1

                Runtime::check_para_id_assignment(bob_id.clone()),

1445

1

                Some(100.into())

1446

1

);

1447

1

            assert_eq!(Runtime::check_para_id_assignment(charlie_id.clone()), None);

1448

1

            assert_eq!(Runtime::check_para_id_assignment(dave_id.clone()), None);

1449

1450

            // In the next session the assignment will not change

1451

1

            assert_eq!(

1452

1

                Runtime::check_para_id_assignment_next_session(alice_id.clone()),

1453

1

                Some(100.into())

1454

1

);

1455

1

            assert_eq!(

1456

1

                Runtime::check_para_id_assignment_next_session(bob_id.clone()),

1457

1

                Some(100.into())

1458

1

);

1459

1

            assert_eq!(

1460

1

                Runtime::check_para_id_assignment_next_session(charlie_id.clone()),

1461

1

                None,

1462

1

);

1463

1

            assert_eq!(

1464

1

                Runtime::check_para_id_assignment_next_session(dave_id.clone()),

1465

1

                None,

1466

1

);

1467

1468

            // Set CHARLIE and DAVE keys

1469

1

            assert_ok!(Session::set_keys(

1470

1

                origin_of(CHARLIE.into()),

1471

1

                crate::SessionKeys {

1472

1

                    nimbus: charlie_id.clone(),

1473

1

},

1474

1

                vec![]

1475

1

));

1476

1

            assert_ok!(Session::set_keys(

1477

1

                origin_of(DAVE.into()),

1478

1

                crate::SessionKeys {

1479

1

                    nimbus: dave_id.clone(),

1480

1

},

1481

1

                vec![]

1482

1

));

1483

1484

            // Set new invulnerables

1485

1

            assert_ok!(Invulnerables::add_invulnerable(

1486

1

                root_origin(),

1487

1

                CHARLIE.into()

1488

1

));

1489

1

            assert_ok!(Invulnerables::add_invulnerable(root_origin(), DAVE.into()));

1490

1491

1

            let session_two_edge = crate::Period::get() * 2;

1492

1

            // Let's run just 2 blocks before the session 2 change first

1493

1

            // Prediction should still be identical, as we are not in the

1494

1

            // edge of a session change

1495

1

            run_to_block(session_two_edge - 2);

1496

1

1497

1

            assert_eq!(

1498

1

                Runtime::para_id_authorities(100.into()),

1499

1

                Some(vec![alice_id.clone(), bob_id.clone()])

1500

1

);

1501

1

            assert_eq!(Runtime::para_id_authorities(1001.into()), Some(vec![]));

1502

1

            assert_eq!(

1503

1

                Runtime::check_para_id_assignment(alice_id.clone()),

1504

1

                Some(100.into())

1505

1

);

1506

1

            assert_eq!(

1507

1

                Runtime::check_para_id_assignment(bob_id.clone()),

1508

1

                Some(100.into())

1509

1

);

1510

1

            assert_eq!(Runtime::check_para_id_assignment(charlie_id.clone()), None);

1511

1

            assert_eq!(Runtime::check_para_id_assignment(dave_id.clone()), None);

1512

1513

            // But in the next session the assignment will change, so future api returns different value

1514

1

            assert_eq!(

1515

1

                Runtime::check_para_id_assignment_next_session(alice_id.clone()),

1516

1

                Some(100.into())

1517

1

);

1518

1

            assert_eq!(

1519

1

                Runtime::check_para_id_assignment_next_session(bob_id.clone()),

1520

1

                Some(100.into())

1521

1

);

1522

1

            assert_eq!(

1523

1

                Runtime::check_para_id_assignment_next_session(charlie_id.clone()),

1524

1

                Some(1001.into()),

1525

1

);

1526

1

            assert_eq!(

1527

1

                Runtime::check_para_id_assignment_next_session(dave_id.clone()),

1528

1

                Some(1001.into()),

1529

1

);

1530

1531

            // Now we run to session edge -1. Here we should predict already with

1532

            // authorities of the next block!

1533

1

            run_to_block(session_two_edge - 1);

1534

1

            assert_eq!(

1535

1

                Runtime::para_id_authorities(100.into()),

1536

1

                Some(vec![alice_id.clone(), bob_id.clone()])

1537

1

);

1538

1

            assert_eq!(

1539

1

                Runtime::para_id_authorities(1001.into()),

1540

1

                Some(vec![charlie_id.clone(), dave_id.clone()])

1541

1

);

1542

1

            assert_eq!(

1543

1

                Runtime::check_para_id_assignment(alice_id.clone()),

1544

1

                Some(100.into())

1545

1

);

1546

1

            assert_eq!(

1547

1

                Runtime::check_para_id_assignment(bob_id.clone()),

1548

1

                Some(100.into())

1549

1

);

1550

1

            assert_eq!(

1551

1

                Runtime::check_para_id_assignment(charlie_id.clone()),

1552

1

                Some(1001.into())

1553

1

);

1554

1

            assert_eq!(

1555

1

                Runtime::check_para_id_assignment(dave_id.clone()),

1556

1

                Some(1001.into())

1557

1

);

1558

1559

            // check_para_id_assignment_next_session returns the same value as check_para_id_assignment

1560

            // because we are on a session boundary

1561

1

            assert_eq!(

1562

1

                Runtime::check_para_id_assignment_next_session(alice_id),

1563

1

                Some(100.into())

1564

1

);

1565

1

            assert_eq!(

1566

1

                Runtime::check_para_id_assignment_next_session(bob_id),

1567

1

                Some(100.into())

1568

1

);

1569

1

            assert_eq!(

1570

1

                Runtime::check_para_id_assignment_next_session(charlie_id),

1571

1

                Some(1001.into())

1572

1

);

1573

1

            assert_eq!(

1574

1

                Runtime::check_para_id_assignment_next_session(dave_id),

1575

1

                Some(1001.into())

1576

1

);

1577

1

});

1578

1

1579

1580

#[test]

1581

1

fn test_author_noting_self_para_id_not_noting() {

1582

1

    ExtBuilder::default().build().execute_with(|| {

1583

1

        let mut sproof = ParaHeaderSproofBuilder::default();

1584

1

        let slot: u64 = 5;

1585

1

        let self_para = parachain_info::Pallet::<Runtime>::get();

1586

1

        let s = ParaHeaderSproofBuilderItem {

1587

1

            para_id: self_para,

1588

1

            author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

1589

1

                parent_hash: Default::default(),

1590

1

                number: Default::default(),

1591

1

                state_root: Default::default(),

1592

1

                extrinsics_root: Default::default(),

1593

1

                digest: sp_runtime::generic::Digest {

1594

1

                    logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

1595

1

},

1596

1

}),

1597

1

};

1598

1

        sproof.items.push(s);

1599

1

1600

1

        set_author_noting_inherent_data(sproof);

1601

1

1602

1

        assert_eq!(AuthorNoting::latest_author(self_para), None);

1603

1

});

1604

1

1605

1606

#[test]

1607

1

fn test_author_noting_not_self_para() {

1608

1

    ExtBuilder::default()

1609

1

        .with_balances(vec![

1610

1

            // Alice gets 10k extra tokens for her mapping deposit

1611

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1612

1

            (AccountId::from(BOB), 100_000 * UNIT),

1613

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1614

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1615

1

])

1616

1

        .with_collators(vec![

1617

1

            (AccountId::from(ALICE), 210 * UNIT),

1618

1

            (AccountId::from(BOB), 100 * UNIT),

1619

1

            (AccountId::from(CHARLIE), 100 * UNIT),

1620

1

            (AccountId::from(DAVE), 100 * UNIT),

1621

1

])

1622

1

        .with_empty_parachains(vec![1001, 1002])

1623

1

        .build()

1624

1

        .execute_with(|| {

1625

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1626

1

            let slot: u64 = 5;

1627

1

            let other_para: ParaId = 1001u32.into();

1628

1

1629

1

            // Charlie and Dave to 1001

1630

1

            let assignment = CollatorAssignment::collator_container_chain();

1631

1

            assert_eq!(

1632

1

                assignment.container_chains[&1001u32.into()],

1633

1

                vec![CHARLIE.into(), DAVE.into()]

1634

1

);

1635

1636

1

            let s = ParaHeaderSproofBuilderItem {

1637

1

                para_id: other_para,

1638

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

1639

1

                    parent_hash: Default::default(),

1640

1

                    number: 1,

1641

1

                    state_root: Default::default(),

1642

1

                    extrinsics_root: Default::default(),

1643

1

                    digest: sp_runtime::generic::Digest {

1644

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

1645

1

},

1646

1

}),

1647

1

};

1648

1

            sproof.items.push(s);

1649

1

1650

1

            set_author_noting_inherent_data(sproof);

1651

1

1652

1

            assert_eq!(

1653

1

                AuthorNoting::latest_author(other_para),

1654

1

                Some(ContainerChainBlockInfo {

1655

1

                    block_number: 1,

1656

1

                    author: AccountId::from(DAVE),

1657

1

                    latest_slot_number: 0.into(),

1658

1

})

1659

1

);

1660

1

});

1661

1

1662

1663

#[test]

1664

1

fn test_author_noting_set_author_and_kill_author_data() {

1665

1

    ExtBuilder::default()

1666

1

        .with_balances(vec![

1667

1

            // Alice gets 10k extra tokens for her mapping deposit

1668

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1669

1

            (AccountId::from(BOB), 100_000 * UNIT),

1670

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1671

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1672

1

])

1673

1

        .with_collators(vec![

1674

1

            (AccountId::from(ALICE), 210 * UNIT),

1675

1

            (AccountId::from(BOB), 100 * UNIT),

1676

1

            (AccountId::from(CHARLIE), 100 * UNIT),

1677

1

            (AccountId::from(DAVE), 100 * UNIT),

1678

1

])

1679

1

        .with_empty_parachains(vec![1001, 1002])

1680

1

        .build()

1681

1

        .execute_with(|| {

1682

1

            let other_para: ParaId = 1001u32.into();

1683

1

1684

1

            assert_ok!(AuthorNoting::set_author(

1685

1

                root_origin(),

1686

1

                other_para,

1687

1

1,

1688

1

                AccountId::from(DAVE),

1689

1

                1.into()

1690

1

));

1691

1692

1

            assert_eq!(

1693

1

                AuthorNoting::latest_author(other_para),

1694

1

                Some(ContainerChainBlockInfo {

1695

1

                    block_number: 1,

1696

1

                    author: AccountId::from(DAVE),

1697

1

                    latest_slot_number: 1.into(),

1698

1

})

1699

1

);

1700

1701

1

            assert_ok!(AuthorNoting::kill_author_data(root_origin(), other_para));

1702

1703

1

            assert_eq!(AuthorNoting::latest_author(other_para), None);

1704

1

});

1705

1

1706

1707

#[test]

1708

1

fn test_author_noting_set_author_and_kill_author_data_bad_origin() {

1709

1

    ExtBuilder::default()

1710

1

        .with_balances(vec![

1711

1

            // Alice gets 10k extra tokens for her mapping deposit

1712

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1713

1

            (AccountId::from(BOB), 100_000 * UNIT),

1714

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1715

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1716

1

])

1717

1

        .with_collators(vec![

1718

1

            (AccountId::from(ALICE), 210 * UNIT),

1719

1

            (AccountId::from(BOB), 100 * UNIT),

1720

1

            (AccountId::from(CHARLIE), 100 * UNIT),

1721

1

            (AccountId::from(DAVE), 100 * UNIT),

1722

1

])

1723

1

        .with_empty_parachains(vec![1001, 1002])

1724

1

        .build()

1725

1

        .execute_with(|| {

1726

1

            let other_para: ParaId = 1001u32.into();

1727

1

1728

1

            assert_noop!(

1729

1

                AuthorNoting::set_author(

1730

1

                    origin_of(ALICE.into()),

1731

1

                    other_para,

1732

1

1,

1733

1

                    AccountId::from(DAVE),

1734

1

                    1.into()

1735

1

),

1736

1

                BadOrigin

1737

1

);

1738

1739

1

            assert_noop!(

1740

1

                AuthorNoting::kill_author_data(origin_of(ALICE.into()), other_para),

1741

1

                BadOrigin

1742

1

);

1743

1

});

1744

1

1745

1746

#[test]

1747

1

fn test_author_noting_runtime_api() {

1748

1

    ExtBuilder::default()

1749

1

        .with_balances(vec![

1750

1

            // Alice gets 10k extra tokens for her mapping deposit

1751

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1752

1

            (AccountId::from(BOB), 100_000 * UNIT),

1753

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1754

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1755

1

])

1756

1

        .with_collators(vec![

1757

1

            (AccountId::from(ALICE), 210 * UNIT),

1758

1

            (AccountId::from(BOB), 100 * UNIT),

1759

1

            (AccountId::from(CHARLIE), 100 * UNIT),

1760

1

            (AccountId::from(DAVE), 100 * UNIT),

1761

1

])

1762

1

        .with_empty_parachains(vec![1001, 1002])

1763

1

        .build()

1764

1

        .execute_with(|| {

1765

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1766

1

            let slot: u64 = 5;

1767

1

            let other_para: ParaId = 1001u32.into();

1768

1

1769

1

            // Charlie and Dave to 1001

1770

1

            let assignment = CollatorAssignment::collator_container_chain();

1771

1

            assert_eq!(

1772

1

                assignment.container_chains[&1001u32.into()],

1773

1

                vec![CHARLIE.into(), DAVE.into()]

1774

1

);

1775

1776

1

            let s = ParaHeaderSproofBuilderItem {

1777

1

                para_id: other_para,

1778

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

1779

1

                    parent_hash: Default::default(),

1780

1

                    number: 1,

1781

1

                    state_root: Default::default(),

1782

1

                    extrinsics_root: Default::default(),

1783

1

                    digest: sp_runtime::generic::Digest {

1784

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

1785

1

},

1786

1

}),

1787

1

};

1788

1

            sproof.items.push(s);

1789

1

1790

1

            set_author_noting_inherent_data(sproof);

1791

1

1792

1

            assert_eq!(

1793

1

                AuthorNoting::latest_author(other_para),

1794

1

                Some(ContainerChainBlockInfo {

1795

1

                    block_number: 1,

1796

1

                    author: AccountId::from(DAVE),

1797

1

                    latest_slot_number: 0.into(),

1798

1

})

1799

1

);

1800

1801

1

            assert_eq!(

1802

1

                Runtime::latest_author(other_para),

1803

1

                Some(AccountId::from(DAVE))

1804

1

);

1805

1

            assert_eq!(Runtime::latest_block_number(other_para), Some(1));

1806

1

});

1807

1

1808

1809

#[test]

1810

1

fn test_collator_assignment_rotation() {

1811

1

    ExtBuilder::default()

1812

1

        .with_balances(vec![

1813

1

            // Alice gets 10k extra tokens for her mapping deposit

1814

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1815

1

            (AccountId::from(BOB), 100_000 * UNIT),

1816

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1817

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1818

1

])

1819

1

        .with_collators(vec![

1820

1

            (AccountId::from(ALICE), 210 * UNIT),

1821

1

            (AccountId::from(BOB), 100 * UNIT),

1822

1

            (AccountId::from(CHARLIE), 100 * UNIT),

1823

1

            (AccountId::from(DAVE), 100 * UNIT),

1824

1

])

1825

1

        .with_empty_parachains(vec![1001, 1002])

1826

1

        .build()

1827

1

        .execute_with(|| {

1828

1

            // Charlie and Dave to 1001

1829

1

            let assignment = CollatorAssignment::collator_container_chain();

1830

1

            let initial_assignment = assignment.clone();

1831

1

            assert_eq!(

1832

1

                assignment.container_chains[&1001u32.into()],

1833

1

                vec![CHARLIE.into(), DAVE.into()]

1834

1

);

1835

1836

1

            let rotation_period = Configuration::config().full_rotation_period;

1837

1

            run_to_session(rotation_period - 2);

1838

1

            set_parachain_inherent_data_random_seed([1; 32]);

1839

1

            run_block();

1840

1

1841

1

            assert!(CollatorAssignment::pending_collator_container_chain().is_none());

1842

1843

1

            run_to_session(rotation_period - 1);

1844

1

            assert_eq!(

1845

1

                CollatorAssignment::collator_container_chain(),

1846

1

                initial_assignment,

1847

1

);

1848

1

            assert!(CollatorAssignment::pending_collator_container_chain().is_some());

1849

1850

1

            run_to_session(rotation_period);

1851

1

            // Assignment changed

1852

1

            assert_ne!(

1853

1

                CollatorAssignment::collator_container_chain(),

1854

1

                initial_assignment,

1855

1

);

1856

1

});

1857

1

1858

1859

#[test]

1860

1

fn session_keys_key_type_id() {

1861

1

    assert_eq!(crate::SessionKeys::key_ids(), vec![NIMBUS_KEY_ID]);

1862

1

1863

1864

#[test]

1865

1

fn test_session_keys_with_authority_mapping() {

1866

1

    ExtBuilder::default()

1867

1

        .with_balances(vec![

1868

1

            // Alice gets 10k extra tokens for her mapping deposit

1869

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1870

1

            (AccountId::from(BOB), 100_000 * UNIT),

1871

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1872

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1873

1

])

1874

1

        .with_empty_parachains(vec![1001, 1002])

1875

1

        .build()

1876

1

        .execute_with(|| {

1877

1

            run_to_block(2);

1878

1

            let key_mapping_session_0 = AuthorityMapping::authority_id_mapping(0).unwrap();

1879

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

1880

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

1881

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1882

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1883

1

1884

1

            assert_eq!(key_mapping_session_0.len(), 2);

1885

1

            assert_eq!(key_mapping_session_0.get(&alice_id), Some(&ALICE.into()));

1886

1

            assert_eq!(key_mapping_session_0.get(&bob_id), Some(&BOB.into()));

1887

1888

            // Everything should match to aura

1889

1

            assert_eq!(authorities(), vec![alice_id.clone(), bob_id.clone()]);

1890

1891

            // Change Alice and Bob keys to something different

1892

            // for now lets change it to alice_2 and bob_2

1893

1

            assert_ok!(Session::set_keys(

1894

1

                origin_of(ALICE.into()),

1895

1

                crate::SessionKeys {

1896

1

                    nimbus: alice_id_2.clone(),

1897

1

},

1898

1

                vec![]

1899

1

));

1900

1

            assert_ok!(Session::set_keys(

1901

1

                origin_of(BOB.into()),

1902

1

                crate::SessionKeys {

1903

1

                    nimbus: bob_id_2.clone(),

1904

1

},

1905

1

                vec![]

1906

1

));

1907

1908

1

            run_to_session(1u32);

1909

1

            let key_mapping_session_0 = AuthorityMapping::authority_id_mapping(0).unwrap();

1910

1

            assert_eq!(key_mapping_session_0.len(), 2);

1911

1

            assert_eq!(key_mapping_session_0.get(&alice_id), Some(&ALICE.into()));

1912

1

            assert_eq!(key_mapping_session_0.get(&bob_id), Some(&BOB.into()));

1913

1914

1

            let key_mapping_session_1 = AuthorityMapping::authority_id_mapping(1).unwrap();

1915

1

            assert_eq!(key_mapping_session_1.len(), 2);

1916

1

            assert_eq!(key_mapping_session_1.get(&alice_id), Some(&ALICE.into()));

1917

1

            assert_eq!(key_mapping_session_1.get(&bob_id), Some(&BOB.into()));

1918

1919

            // Everything should match to aura

1920

1

            assert_eq!(authorities(), vec![alice_id.clone(), bob_id.clone()]);

1921

//

1922

1923

1

            run_to_session(2u32);

1924

1

            assert!(AuthorityMapping::authority_id_mapping(0).is_none());

1925

1926

1

            let key_mapping_session_1 = AuthorityMapping::authority_id_mapping(1).unwrap();

1927

1

            assert_eq!(key_mapping_session_1.len(), 2);

1928

1

            assert_eq!(key_mapping_session_1.get(&alice_id), Some(&ALICE.into()));

1929

1

            assert_eq!(key_mapping_session_1.get(&bob_id), Some(&BOB.into()));

1930

1931

1

            let key_mapping_session_2 = AuthorityMapping::authority_id_mapping(2).unwrap();

1932

1

            assert_eq!(key_mapping_session_2.len(), 2);

1933

1

            assert_eq!(key_mapping_session_2.get(&alice_id_2), Some(&ALICE.into()));

1934

1

            assert_eq!(key_mapping_session_2.get(&bob_id_2), Some(&BOB.into()));

1935

1936

            // Everything should match to aura

1937

1

            assert_eq!(authorities(), vec![alice_id_2, bob_id_2]);

1938

1

});

1939

1

1940

1941

#[test]

1942

1

fn test_session_keys_with_authority_assignment() {

1943

1

    ExtBuilder::default()

1944

1

        .with_balances(vec![

1945

1

            // Alice gets 10k extra tokens for her mapping deposit

1946

1

            (AccountId::from(ALICE), 210_000 * UNIT),

1947

1

            (AccountId::from(BOB), 100_000 * UNIT),

1948

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

1949

1

            (AccountId::from(DAVE), 100_000 * UNIT),

1950

1

])

1951

1

        .with_empty_parachains(vec![1001, 1002])

1952

1

        .build()

1953

1

        .execute_with(|| {

1954

1

            run_to_block(2);

1955

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

1956

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

1957

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1958

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1959

1

1960

1

            let key_mapping_session_0 = AuthorityAssignment::collator_container_chain(0).unwrap();

1961

1

            assert_eq!(

1962

1

                key_mapping_session_0.orchestrator_chain,

1963

1

                vec![alice_id.clone(), bob_id.clone()],

1964

1

);

1965

1

            assert_eq!(

1966

1

                CollatorAssignment::collator_container_chain().orchestrator_chain,

1967

1

                vec![AccountId::from(ALICE), AccountId::from(BOB)],

1968

1

);

1969

1970

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1).unwrap();

1971

1

            assert_eq!(key_mapping_session_1, key_mapping_session_0,);

1972

1

            let old_assignment_session_1 =

1973

1

                CollatorAssignment::pending_collator_container_chain().unwrap();

1974

1

            assert_eq!(

1975

1

                old_assignment_session_1,

1976

1

                CollatorAssignment::collator_container_chain(),

1977

1

);

1978

1979

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2);

1980

1

            assert!(key_mapping_session_2.is_none());

1981

1982

            // Everything should match to aura

1983

1

            assert_eq!(authorities(), vec![alice_id.clone(), bob_id.clone()]);

1984

1985

            // Change Alice and Bob keys to something different

1986

            // for now lets change it to alice_2 and bob_2

1987

1

            assert_ok!(Session::set_keys(

1988

1

                origin_of(ALICE.into()),

1989

1

                crate::SessionKeys {

1990

1

                    nimbus: alice_id_2.clone(),

1991

1

},

1992

1

                vec![]

1993

1

));

1994

1

            assert_ok!(Session::set_keys(

1995

1

                origin_of(BOB.into()),

1996

1

                crate::SessionKeys {

1997

1

                    nimbus: bob_id_2.clone(),

1998

1

},

1999

1

                vec![]

2000

1

));

2001

2002

1

            run_to_session(1u32);

2003

1

            let old_key_mapping_session_1 = key_mapping_session_1;

2004

1

2005

1

            // Session 0 got removed

2006

1

            let key_mapping_session_0 = AuthorityAssignment::collator_container_chain(0);

2007

1

            assert!(key_mapping_session_0.is_none());

2008

2009

            // The values at session 1 did not change

2010

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1).unwrap();

2011

1

            assert_eq!(key_mapping_session_1, old_key_mapping_session_1,);

2012

1

            assert_eq!(

2013

1

                CollatorAssignment::collator_container_chain(),

2014

1

                old_assignment_session_1,

2015

1

);

2016

2017

            // Session 2 uses the new keys

2018

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2).unwrap();

2019

1

            assert_eq!(

2020

1

                key_mapping_session_2.orchestrator_chain,

2021

1

                vec![alice_id_2.clone(), bob_id_2.clone()],

2022

1

);

2023

1

            assert_eq!(CollatorAssignment::pending_collator_container_chain(), None);

2024

2025

1

            let key_mapping_session_3 = AuthorityAssignment::collator_container_chain(3);

2026

1

            assert!(key_mapping_session_3.is_none());

2027

2028

            // Everything should match to aura

2029

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

2030

2031

1

            run_to_session(2u32);

2032

1

2033

1

            // Session 1 got removed

2034

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1);

2035

1

            assert!(key_mapping_session_1.is_none());

2036

2037

            // Session 2 uses the new keys

2038

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2).unwrap();

2039

1

            assert_eq!(

2040

1

                key_mapping_session_2.orchestrator_chain,

2041

1

                vec![alice_id_2.clone(), bob_id_2.clone()],

2042

1

);

2043

1

            assert_eq!(

2044

1

                old_assignment_session_1,

2045

1

                CollatorAssignment::collator_container_chain(),

2046

1

);

2047

2048

            // Session 3 uses the new keys

2049

1

            let key_mapping_session_3 = AuthorityAssignment::collator_container_chain(3).unwrap();

2050

1

            assert_eq!(

2051

1

                key_mapping_session_3.orchestrator_chain,

2052

1

                vec![alice_id_2.clone(), bob_id_2.clone()],

2053

1

);

2054

1

            assert_eq!(CollatorAssignment::pending_collator_container_chain(), None);

2055

2056

1

            let key_mapping_session_4 = AuthorityAssignment::collator_container_chain(4);

2057

1

            assert!(key_mapping_session_4.is_none());

2058

2059

            // Everything should match to aura

2060

1

            assert_eq!(authorities(), vec![alice_id_2, bob_id_2]);

2061

1

});

2062

1

2063

2064

2

fn call_transfer(

2065

2

    dest: sp_runtime::MultiAddress<sp_runtime::AccountId32, ()>,

2066

2

    value: u128,

2067

2

) -> RuntimeCall {

2068

2

    RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death { dest, value })

2069

2

2070

2071

#[test]

2072

1

fn test_proxy_any() {

2073

1

    ExtBuilder::default()

2074

1

        .with_balances(vec![

2075

1

            // Alice gets 10k extra tokens for her mapping deposit

2076

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2077

1

            (AccountId::from(BOB), 100_000 * UNIT),

2078

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2079

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2080

1

])

2081

1

        .build()

2082

1

        .execute_with(|| {

2083

1

            run_to_block(2);

2084

1

2085

1

            let delay = 0;

2086

1

            assert_ok!(Proxy::add_proxy(

2087

1

                origin_of(ALICE.into()),

2088

1

                AccountId::from(BOB).into(),

2089

1

                ProxyType::Any,

2090

1

                delay

2091

1

));

2092

2093

1

            let balance_before = System::account(AccountId::from(BOB)).data.free;

2094

1

            let call = Box::new(call_transfer(AccountId::from(BOB).into(), 200_000));

2095

1

            assert_ok!(Proxy::proxy(

2096

1

                origin_of(BOB.into()),

2097

1

                AccountId::from(ALICE).into(),

2098

1

                None,

2099

1

                call

2100

1

));

2101

1

            let balance_after = System::account(AccountId::from(BOB)).data.free;

2102

1

2103

1

            assert_eq!(balance_after, balance_before + 200_000);

2104

1

});

2105

1

2106

2107

#[test]

2108

1

fn test_proxy_non_transfer() {

2109

1

    ExtBuilder::default()

2110

1

        .with_balances(vec![

2111

1

            // Alice gets 10k extra tokens for her mapping deposit

2112

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2113

1

            (AccountId::from(BOB), 100_000 * UNIT),

2114

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2115

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2116

1

])

2117

1

        .build()

2118

1

        .execute_with(|| {

2119

1

            run_to_block(2);

2120

1

2121

1

            let delay = 0;

2122

1

            assert_ok!(Proxy::add_proxy(

2123

1

                origin_of(ALICE.into()),

2124

1

                AccountId::from(BOB).into(),

2125

1

                ProxyType::NonTransfer,

2126

1

                delay

2127

1

));

2128

2129

1

            let balance_before = System::account(AccountId::from(BOB)).data.free;

2130

1

            let call = Box::new(call_transfer(AccountId::from(BOB).into(), 200_000));

2131

1

            // The extrinsic succeeds but the call is filtered, so no transfer is actually done

2132

1

            assert_ok!(Proxy::proxy(

2133

1

                origin_of(BOB.into()),

2134

1

                AccountId::from(ALICE).into(),

2135

1

                None,

2136

1

                call

2137

1

));

2138

1

            let balance_after = System::account(AccountId::from(BOB)).data.free;

2139

1

2140

1

            assert_eq!(balance_after, balance_before);

2141

1

});

2142

1

2143

2144

#[test]

2145

1

fn test_proxy_utility() {

2146

1

    // All proxy types should be able to use Utility pallet, but we ensure

2147

1

    // subcalls don't allow to circumvent filters.

2148

1

2149

1

    // Dummy match to ensure we update this test when adding new proxy types.

2150

1

    match ProxyType::Any {

2151

        ProxyType::Any

2152

        | ProxyType::NonTransfer

2153

        | ProxyType::Governance

2154

        | ProxyType::Staking

2155

        | ProxyType::CancelProxy

2156

        | ProxyType::Balances

2157

        | ProxyType::Registrar

2158

        | ProxyType::SudoRegistrar

2159

1

        | ProxyType::SessionKeyManagement => (),

2160

1

};

2161

1

2162

1

    // All except for any

2163

1

    let proxy_types = &[

2164

1

        ProxyType::NonTransfer,

2165

1

        ProxyType::Governance,

2166

1

        ProxyType::Staking,

2167

1

        ProxyType::CancelProxy,

2168

1

        ProxyType::Balances,

2169

1

        ProxyType::Registrar,

2170

1

        ProxyType::SudoRegistrar,

2171

1

        ProxyType::SessionKeyManagement,

2172

1

];

2173

2174

9

    for &proxy_type in proxy_types {

2175

8

        ExtBuilder::default()

2176

8

            .with_balances(vec![

2177

8

                // Alice gets 10k extra tokens for her mapping deposit

2178

8

                (AccountId::from(ALICE), 210_000 * UNIT),

2179

8

                (AccountId::from(BOB), 100_000 * UNIT),

2180

8

                (AccountId::from(CHARLIE), 100_000 * UNIT),

2181

8

                (AccountId::from(DAVE), 100_000 * UNIT),

2182

8

])

2183

8

            .with_collators(vec![

2184

8

                (AccountId::from(ALICE), 210 * UNIT),

2185

8

                (AccountId::from(BOB), 100 * UNIT),

2186

8

])

2187

8

            .with_sudo(AccountId::from(ALICE))

2188

8

            .build()

2189

8

            .execute_with(|| {

2190

8

                assert_ok!(Proxy::add_proxy(

2191

8

                    origin_of(ALICE.into()),

2192

8

                    AccountId::from(BOB).into(),

2193

8

                    proxy_type,

2194

8

2195

8

));

2196

2197

8

                let free_balance = Balances::free_balance(AccountId::from(BOB));

2198

8

2199

8

                assert_ok!(Proxy::proxy(

2200

8

                    origin_of(BOB.into()),

2201

8

                    AccountId::from(ALICE).into(),

2202

8

                    None,

2203

8

                    Box::new(

2204

8

                        pallet_sudo::Call::sudo {

2205

8

                            call: Box::new(

2206

8

                                pallet_utility::Call::batch {

2207

8

                                    calls: vec![pallet_balances::Call::force_set_balance {

2208

8

                                        who: AccountId::from(BOB).into(),

2209

8

                                        new_free: 42424242424242

2210

8

2211

8

                                    .into()]

2212

8

2213

8

                                .into()

2214

8

2215

8

2216

8

                        .into()

2217

8

2218

8

));

2219

2220

8

                assert_eq!(Balances::free_balance(AccountId::from(BOB)), free_balance);

2221

8

});

2222

8

2223

1

2224

2225

#[test]

2226

1

fn check_well_known_keys() {

2227

    use frame_support::traits::PalletInfo;

2228

2229

    // Pallet is named "Paras" in Polkadot.

2230

1

    assert_eq!(

2231

1

        well_known_keys::PARAS_HEADS_INDEX,

2232

1

        frame_support::storage::storage_prefix(b"Paras", b"Heads")

2233

1

);

2234

2235

    // Tanssi storage. Since we cannot access the storages themselves,

2236

    // we test the pallet prefix matches and then compute manually the full prefix.

2237

1

    assert_eq!(

2238

1

        crate::PalletInfo::name::<AuthorityAssignment>(),

2239

1

        Some("AuthorityAssignment")

2240

1

);

2241

1

    assert_eq!(

2242

1

        well_known_keys::AUTHORITY_ASSIGNMENT_PREFIX,

2243

1

        frame_support::storage::storage_prefix(b"AuthorityAssignment", b"CollatorContainerChain")

2244

1

);

2245

2246

1

    assert_eq!(crate::PalletInfo::name::<Session>(), Some("Session"));

2247

1

    assert_eq!(

2248

1

        well_known_keys::SESSION_INDEX,

2249

1

        frame_support::storage::storage_prefix(b"Session", b"CurrentIndex")

2250

1

);

2251

1

2252

2253

#[test]

2254

1

fn test_staking_no_candidates_in_genesis() {

2255

1

    ExtBuilder::default()

2256

1

        .with_balances(vec![

2257

1

            // Alice gets 10k extra tokens for her mapping deposit

2258

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2259

1

            (AccountId::from(BOB), 100_000 * UNIT),

2260

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2261

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2262

1

])

2263

1

        .with_collators(vec![

2264

1

            (AccountId::from(ALICE), 210 * UNIT),

2265

1

            (AccountId::from(BOB), 100 * UNIT),

2266

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2267

1

            (AccountId::from(DAVE), 100 * UNIT),

2268

1

])

2269

1

        .with_empty_parachains(vec![1001, 1002])

2270

1

        .build()

2271

1

        .execute_with(|| {

2272

1

            run_to_block(2);

2273

1

2274

1

            let initial_candidates =

2275

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2276

1

2277

1

            assert_eq!(initial_candidates, vec![]);

2278

1

});

2279

1

2280

2281

#[test]

2282

1

fn test_staking_join() {

2283

1

    ExtBuilder::default()

2284

1

        .with_balances(vec![

2285

1

            // Alice gets 10k extra tokens for her mapping deposit

2286

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2287

1

            (AccountId::from(BOB), 100_000 * UNIT),

2288

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2289

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2290

1

])

2291

1

        .with_collators(vec![

2292

1

            (AccountId::from(ALICE), 210 * UNIT),

2293

1

            (AccountId::from(BOB), 100 * UNIT),

2294

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2295

1

            (AccountId::from(DAVE), 100 * UNIT),

2296

1

])

2297

1

        .with_empty_parachains(vec![1001, 1002])

2298

1

        .build()

2299

1

        .execute_with(|| {

2300

1

            run_to_block(2);

2301

1

2302

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

2303

1

            assert_eq!(System::account(AccountId::from(ALICE)).data.reserved, 0);

2304

1

            let stake = MinimumSelfDelegation::get() * 10;

2305

1

            assert_ok!(PooledStaking::request_delegate(

2306

1

                origin_of(ALICE.into()),

2307

1

                ALICE.into(),

2308

1

                TargetPool::AutoCompounding,

2309

1

                stake

2310

1

));

2311

2312

            // Immediately after joining, Alice is the top candidate

2313

1

            let eligible_candidates =

2314

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2315

1

            assert_eq!(

2316

1

                eligible_candidates,

2317

1

                vec![EligibleCandidate {

2318

1

                    candidate: ALICE.into(),

2319

1

                    stake

2320

1

}]

2321

1

);

2322

2323

            // And staked amount is immediately marked as "reserved"

2324

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

2325

1

            assert_eq!(balance_before - balance_after, stake);

2326

1

            assert_eq!(System::account(AccountId::from(ALICE)).data.reserved, stake);

2327

1

});

2328

1

2329

2330

#[test]

2331

1

fn test_staking_join_no_keys_registered() {

2332

1

    ExtBuilder::default()

2333

1

        .with_balances(vec![

2334

1

            // Alice gets 10k extra tokens for her mapping deposit

2335

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2336

1

            (AccountId::from(BOB), 100_000 * UNIT),

2337

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2338

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2339

1

])

2340

1

        .with_collators(vec![

2341

1

            (AccountId::from(ALICE), 210 * UNIT),

2342

1

            (AccountId::from(BOB), 100 * UNIT),

2343

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2344

1

            (AccountId::from(DAVE), 100 * UNIT),

2345

1

])

2346

1

        .with_empty_parachains(vec![

2347

1

            1001,

2348

1

            1002,

2349

1

])

2350

1

2351

1

        .build()

2352

1

        .execute_with(|| {

2353

1

            run_to_block(2);

2354

1

2355

1

            let stake = MinimumSelfDelegation::get() * 10;

2356

1

            let new_account = AccountId::from([42u8; 32]);

2357

1

            assert_ok!(Balances::transfer_allow_death(

2358

1

                origin_of(ALICE.into()),

2359

1

                new_account.clone().into(),

2360

1

                stake * 2

2361

1

));

2362

1

            let balance_before = System::account(new_account.clone()).data.free;

2363

1

            assert_eq!(System::account(new_account.clone()).data.reserved, 0);

2364

1

            assert_ok!(PooledStaking::request_delegate(

2365

1

                origin_of(new_account.clone()),

2366

1

                new_account.clone(),

2367

1

                TargetPool::AutoCompounding,

2368

1

                stake

2369

1

));

2370

2371

            // The new account should be the top candidate but it has no keys registered in

2372

            // pallet_session, so it is not eligible

2373

1

            assert!(!<Runtime as pallet_pooled_staking::Config>::EligibleCandidatesFilter::is_candidate_eligible(&new_account));

2374

1

            let eligible_candidates =

2375

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2376

1

2377

1

            assert_eq!(eligible_candidates, vec![]);

2378

2379

            // And staked amount is immediately marked as "reserved"

2380

1

            let balance_after = System::account(new_account.clone()).data.free;

2381

1

            assert_eq!(balance_before - balance_after, stake);

2382

1

            assert_eq!(System::account(new_account.clone()).data.reserved, stake);

2383

1

});

2384

1

2385

2386

#[test]

2387

1

fn test_staking_register_keys_after_joining() {

2388

1

    ExtBuilder::default()

2389

1

        .with_balances(vec![

2390

1

            // Alice gets 10k extra tokens for her mapping deposit

2391

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2392

1

            (AccountId::from(BOB), 100_000 * UNIT),

2393

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2394

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2395

1

])

2396

1

        .with_collators(vec![

2397

1

            (AccountId::from(ALICE), 210 * UNIT),

2398

1

            (AccountId::from(BOB), 100 * UNIT),

2399

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2400

1

            (AccountId::from(DAVE), 100 * UNIT),

2401

1

])

2402

1

        .with_empty_parachains(vec![

2403

1

            1001,

2404

1

            1002,

2405

1

])

2406

1

2407

1

        .build()

2408

1

        .execute_with(|| {

2409

1

            run_to_block(2);

2410

1

2411

1

            let stake = MinimumSelfDelegation::get() * 10;

2412

1

            let new_account = AccountId::from([42u8; 32]);

2413

1

            assert_ok!(Balances::transfer_allow_death(

2414

1

                origin_of(ALICE.into()),

2415

1

                new_account.clone().into(),

2416

1

                stake * 2

2417

1

));

2418

1

            let balance_before = System::account(new_account.clone()).data.free;

2419

1

            assert_eq!(System::account(new_account.clone()).data.reserved, 0);

2420

1

            assert_ok!(PooledStaking::request_delegate(

2421

1

                origin_of(new_account.clone()),

2422

1

                new_account.clone(),

2423

1

                TargetPool::AutoCompounding,

2424

1

                stake

2425

1

));

2426

2427

            // The new account should be the top candidate but it has no keys registered in

2428

            // pallet_session, so it is not eligible

2429

1

            assert!(!<Runtime as pallet_pooled_staking::Config>::EligibleCandidatesFilter::is_candidate_eligible(&new_account));

2430

1

            let eligible_candidates =

2431

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2432

1

            assert_eq!(eligible_candidates, vec![]);

2433

2434

            // And staked amount is immediately marked as "reserved"

2435

1

            let balance_after = System::account(new_account.clone()).data.free;

2436

1

            assert_eq!(balance_before - balance_after, stake);

2437

1

            assert_eq!(System::account(new_account.clone()).data.reserved, stake);

2438

2439

            // Now register the keys

2440

1

            let new_account_id = get_aura_id_from_seed(&new_account.to_string());

2441

1

            assert_ok!(Session::set_keys(

2442

1

                origin_of(new_account.clone()),

2443

1

                crate::SessionKeys {

2444

1

                    nimbus: new_account_id,

2445

1

},

2446

1

                vec![]

2447

1

));

2448

2449

            // Now eligible according to filter

2450

1

            assert!(<Runtime as pallet_pooled_staking::Config>::EligibleCandidatesFilter::is_candidate_eligible(&new_account));

2451

            // But not eligible according to pallet_pooled_staking, need to manually update candidate list

2452

1

            let eligible_candidates =

2453

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2454

1

            assert_eq!(eligible_candidates, vec![]);

2455

2456

            // Update candidate list

2457

1

            assert_ok!(PooledStaking::update_candidate_position(

2458

1

                origin_of(BOB.into()),

2459

1

                vec![new_account.clone()]

2460

1

));

2461

2462

            // Now it is eligible

2463

1

            let eligible_candidates =

2464

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2465

1

            assert_eq!(

2466

1

                eligible_candidates,

2467

1

                vec![EligibleCandidate {

2468

1

                    candidate: new_account.clone(),

2469

1

                    stake

2470

1

}]

2471

1

);

2472

1

});

2473

1

2474

2475

#[test]

2476

1

fn test_staking_join_bad_origin() {

2477

1

    ExtBuilder::default()

2478

1

        .with_balances(vec![

2479

1

            // Alice gets 10k extra tokens for her mapping deposit

2480

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2481

1

            (AccountId::from(BOB), 100_000 * UNIT),

2482

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2483

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2484

1

])

2485

1

        .with_collators(vec![

2486

1

            (AccountId::from(ALICE), 210 * UNIT),

2487

1

            (AccountId::from(BOB), 100 * UNIT),

2488

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2489

1

            (AccountId::from(DAVE), 100 * UNIT),

2490

1

])

2491

1

        .with_empty_parachains(vec![1001, 1002])

2492

1

        .build()

2493

1

        .execute_with(|| {

2494

1

            run_to_block(2);

2495

1

2496

1

            let stake = 10 * MinimumSelfDelegation::get();

2497

1

            assert_noop!(

2498

1

                PooledStaking::request_delegate(

2499

1

                    root_origin(),

2500

1

                    ALICE.into(),

2501

1

                    TargetPool::AutoCompounding,

2502

1

                    stake

2503

1

),

2504

1

                BadOrigin,

2505

1

);

2506

1

});

2507

1

2508

2509

#[test]

2510

1

fn test_staking_join_below_self_delegation_min() {

2511

1

    ExtBuilder::default()

2512

1

        .with_balances(vec![

2513

1

            // Alice gets 10k extra tokens for her mapping deposit

2514

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2515

1

            (AccountId::from(BOB), 100_000 * UNIT),

2516

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2517

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2518

1

])

2519

1

        .with_collators(vec![

2520

1

            (AccountId::from(ALICE), 210 * UNIT),

2521

1

            (AccountId::from(BOB), 100 * UNIT),

2522

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2523

1

            (AccountId::from(DAVE), 100 * UNIT),

2524

1

])

2525

1

        .with_empty_parachains(vec![1001, 1002])

2526

1

        .build()

2527

1

        .execute_with(|| {

2528

1

            run_to_block(2);

2529

1

2530

1

            let stake1 = MinimumSelfDelegation::get() / 3;

2531

1

            assert_ok!(PooledStaking::request_delegate(

2532

1

                origin_of(ALICE.into()),

2533

1

                ALICE.into(),

2534

1

                TargetPool::AutoCompounding,

2535

1

                stake1

2536

1

));

2537

2538

            // Since stake is below MinimumSelfDelegation, the join operation succeeds

2539

            // but the candidate is not eligible

2540

1

            let eligible_candidates =

2541

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2542

1

            assert_eq!(eligible_candidates, vec![],);

2543

2544

1

            let stake2 = MinimumSelfDelegation::get() - stake1 - 1;

2545

1

            assert_ok!(PooledStaking::request_delegate(

2546

1

                origin_of(ALICE.into()),

2547

1

                ALICE.into(),

2548

1

                TargetPool::AutoCompounding,

2549

1

                stake2,

2550

1

));

2551

2552

            // Still below, missing 1 unit

2553

1

            let eligible_candidates =

2554

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2555

1

            assert_eq!(eligible_candidates, vec![],);

2556

2557

1

            let stake3 = 1;

2558

1

            assert_ok!(PooledStaking::request_delegate(

2559

1

                origin_of(ALICE.into()),

2560

1

                ALICE.into(),

2561

1

                TargetPool::AutoCompounding,

2562

1

                stake3,

2563

1

));

2564

2565

            // Increasing the stake to above MinimumSelfDelegation makes the candidate eligible

2566

1

            let eligible_candidates =

2567

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2568

1

            assert_eq!(

2569

1

                eligible_candidates,

2570

1

                vec![EligibleCandidate {

2571

1

                    candidate: ALICE.into(),

2572

1

                    stake: stake1 + stake2 + stake3

2573

1

}],

2574

1

);

2575

1

});

2576

1

2577

2578

#[test]

2579

1

fn test_staking_join_no_self_delegation() {

2580

1

    ExtBuilder::default()

2581

1

        .with_balances(vec![

2582

1

            // Alice gets 10k extra tokens for her mapping deposit

2583

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2584

1

            (AccountId::from(BOB), 100_000 * UNIT),

2585

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2586

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2587

1

])

2588

1

        .with_collators(vec![

2589

1

            (AccountId::from(ALICE), 210 * UNIT),

2590

1

            (AccountId::from(BOB), 100 * UNIT),

2591

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2592

1

            (AccountId::from(DAVE), 100 * UNIT),

2593

1

])

2594

1

        .with_empty_parachains(vec![1001, 1002])

2595

1

        .build()

2596

1

        .execute_with(|| {

2597

1

            run_to_block(2);

2598

1

2599

1

            // Bob delegates to Alice, but Alice is not a valid candidate (not enough self-delegation)

2600

1

            let stake = 10 * MinimumSelfDelegation::get();

2601

1

            assert_ok!(PooledStaking::request_delegate(

2602

1

                origin_of(BOB.into()),

2603

1

                ALICE.into(),

2604

1

                TargetPool::AutoCompounding,

2605

1

                stake,

2606

1

));

2607

2608

1

            let eligible_candidates =

2609

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2610

1

            assert_eq!(eligible_candidates, vec![],);

2611

1

});

2612

1

2613

2614

#[test]

2615

1

fn test_staking_join_before_self_delegation() {

2616

1

    ExtBuilder::default()

2617

1

        .with_balances(vec![

2618

1

            // Alice gets 10k extra tokens for her mapping deposit

2619

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2620

1

            (AccountId::from(BOB), 100_000 * UNIT),

2621

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2622

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2623

1

])

2624

1

        .with_collators(vec![

2625

1

            (AccountId::from(ALICE), 210 * UNIT),

2626

1

            (AccountId::from(BOB), 100 * UNIT),

2627

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2628

1

            (AccountId::from(DAVE), 100 * UNIT),

2629

1

])

2630

1

        .with_empty_parachains(vec![1001, 1002])

2631

1

        .build()

2632

1

        .execute_with(|| {

2633

1

            run_to_block(2);

2634

1

2635

1

            // Bob delegates to Alice, but Alice is not a valid candidate (not enough self-delegation)

2636

1

            let stake = 10 * MinimumSelfDelegation::get();

2637

1

            assert_ok!(PooledStaking::request_delegate(

2638

1

                origin_of(BOB.into()),

2639

1

                ALICE.into(),

2640

1

                TargetPool::AutoCompounding,

2641

1

                stake

2642

1

));

2643

2644

1

            let eligible_candidates =

2645

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2646

1

            assert_eq!(eligible_candidates, vec![],);

2647

2648

1

            run_to_session(2);

2649

1

            assert_ok!(PooledStaking::execute_pending_operations(

2650

1

                origin_of(ALICE.into()),

2651

1

                vec![PendingOperationQuery {

2652

1

                    delegator: BOB.into(),

2653

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2654

1

                        candidate: ALICE.into(),

2655

1

                        at: 0,

2656

1

2657

1

}]

2658

1

            ),);

2659

2660

            // Now Alice joins with enough self-delegation

2661

1

            assert_ok!(PooledStaking::request_delegate(

2662

1

                origin_of(ALICE.into()),

2663

1

                ALICE.into(),

2664

1

                TargetPool::AutoCompounding,

2665

1

                stake

2666

1

));

2667

2668

            // Alice is a valid candidate, and Bob's stake is also counted

2669

1

            let eligible_candidates =

2670

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2671

1

            assert_eq!(

2672

1

                eligible_candidates,

2673

1

                vec![EligibleCandidate {

2674

1

                    candidate: ALICE.into(),

2675

1

                    stake: stake * 2,

2676

1

}],

2677

1

);

2678

1

});

2679

1

2680

2681

#[test]

2682

1

fn test_staking_join_twice_in_same_block() {

2683

1

    ExtBuilder::default()

2684

1

        .with_balances(vec![

2685

1

            // Alice gets 10k extra tokens for her mapping deposit

2686

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2687

1

            (AccountId::from(BOB), 100_000 * UNIT),

2688

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2689

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2690

1

])

2691

1

        .with_collators(vec![

2692

1

            (AccountId::from(ALICE), 210 * UNIT),

2693

1

            (AccountId::from(BOB), 100 * UNIT),

2694

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2695

1

            (AccountId::from(DAVE), 100 * UNIT),

2696

1

])

2697

1

        .with_empty_parachains(vec![1001, 1002])

2698

1

        .build()

2699

1

        .execute_with(|| {

2700

1

            run_to_block(2);

2701

1

2702

1

            let stake1 = 10 * MinimumSelfDelegation::get();

2703

1

            assert_ok!(PooledStaking::request_delegate(

2704

1

                origin_of(ALICE.into()),

2705

1

                ALICE.into(),

2706

1

                TargetPool::AutoCompounding,

2707

1

                stake1

2708

1

));

2709

2710

1

            let stake2 = 9 * MinimumSelfDelegation::get();

2711

1

            assert_ok!(PooledStaking::request_delegate(

2712

1

                origin_of(ALICE.into()),

2713

1

                ALICE.into(),

2714

1

                TargetPool::AutoCompounding,

2715

1

                stake2

2716

1

));

2717

2718

            // Both operations succeed and the total stake is the sum of the individual stakes

2719

1

            let eligible_candidates =

2720

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2721

1

2722

1

            assert_eq!(

2723

1

                eligible_candidates,

2724

1

                vec![EligibleCandidate {

2725

1

                    candidate: ALICE.into(),

2726

1

                    stake: stake1 + stake2,

2727

1

}]

2728

1

);

2729

2730

1

            run_to_session(2);

2731

1

2732

1

            assert_ok!(PooledStaking::execute_pending_operations(

2733

1

                origin_of(ALICE.into()),

2734

1

                vec![PendingOperationQuery {

2735

1

                    delegator: ALICE.into(),

2736

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2737

1

                        candidate: ALICE.into(),

2738

1

                        at: 0,

2739

1

2740

1

}]

2741

1

            ),);

2742

2743

            // TODO: ensure the total stake has been moved to auto compounding pool

2744

1

});

2745

1

2746

2747

#[test]

2748

1

fn test_staking_join_execute_before_time() {

2749

1

    ExtBuilder::default()

2750

1

        .with_balances(vec![

2751

1

            // Alice gets 10k extra tokens for her mapping deposit

2752

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2753

1

            (AccountId::from(BOB), 100_000 * UNIT),

2754

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2755

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2756

1

])

2757

1

        .with_collators(vec![

2758

1

            (AccountId::from(ALICE), 210 * UNIT),

2759

1

            (AccountId::from(BOB), 100 * UNIT),

2760

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2761

1

            (AccountId::from(DAVE), 100 * UNIT),

2762

1

])

2763

1

        .with_empty_parachains(vec![1001, 1002])

2764

1

        .build()

2765

1

        .execute_with(|| {

2766

1

            run_to_block(2);

2767

1

2768

1

            let stake = 10 * MinimumSelfDelegation::get();

2769

1

            assert_ok!(PooledStaking::request_delegate(

2770

1

                origin_of(ALICE.into()),

2771

1

                ALICE.into(),

2772

1

                TargetPool::AutoCompounding,

2773

1

                stake

2774

1

));

2775

2776

            // Immediately after joining, Alice is the top candidate

2777

1

            let eligible_candidates =

2778

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2779

1

            assert_eq!(

2780

1

                eligible_candidates,

2781

1

                vec![EligibleCandidate {

2782

1

                    candidate: ALICE.into(),

2783

1

                    stake

2784

1

}]

2785

1

);

2786

2787

            // We called request_delegate in session 0, we will be able to execute it starting from session 2

2788

1

            let start_of_session_2 = session_to_block(2);

2789

1

            // Session 2 starts at block 600, but run_to_session runs to block 601, so subtract 2 here to go to 599

2790

1

            run_to_block(start_of_session_2 - 2);

2791

1

            assert_noop!(

2792

1

                PooledStaking::execute_pending_operations(

2793

1

                    origin_of(ALICE.into()),

2794

1

                    vec![PendingOperationQuery {

2795

1

                        delegator: ALICE.into(),

2796

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

2797

1

                            candidate: ALICE.into(),

2798

1

                            at: 0,

2799

1

2800

1

}]

2801

1

),

2802

1

                pallet_pooled_staking::Error::<Runtime>::RequestCannotBeExecuted(0),

2803

1

);

2804

2805

1

            run_to_block(start_of_session_2);

2806

1

            assert_ok!(PooledStaking::execute_pending_operations(

2807

1

                origin_of(ALICE.into()),

2808

1

                vec![PendingOperationQuery {

2809

1

                    delegator: ALICE.into(),

2810

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2811

1

                        candidate: ALICE.into(),

2812

1

                        at: 0,

2813

1

2814

1

}]

2815

1

            ),);

2816

1

});

2817

1

2818

2819

#[test]

2820

1

fn test_staking_join_execute_any_origin() {

2821

1

    ExtBuilder::default()

2822

1

        .with_balances(vec![

2823

1

            // Alice gets 10k extra tokens for her mapping deposit

2824

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2825

1

            (AccountId::from(BOB), 100_000 * UNIT),

2826

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2827

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2828

1

])

2829

1

        .with_collators(vec![

2830

1

            (AccountId::from(ALICE), 210 * UNIT),

2831

1

            (AccountId::from(BOB), 100 * UNIT),

2832

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2833

1

            (AccountId::from(DAVE), 100 * UNIT),

2834

1

])

2835

1

        .with_empty_parachains(vec![1001, 1002])

2836

1

        .build()

2837

1

        .execute_with(|| {

2838

1

            run_to_block(2);

2839

1

2840

1

            let stake = 10 * MinimumSelfDelegation::get();

2841

1

            assert_ok!(PooledStaking::request_delegate(

2842

1

                origin_of(ALICE.into()),

2843

1

                ALICE.into(),

2844

1

                TargetPool::AutoCompounding,

2845

1

                stake

2846

1

));

2847

2848

            // Immediately after joining, Alice is the top candidate

2849

1

            let eligible_candidates =

2850

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2851

1

            assert_eq!(

2852

1

                eligible_candidates,

2853

1

                vec![EligibleCandidate {

2854

1

                    candidate: ALICE.into(),

2855

1

                    stake

2856

1

}]

2857

1

);

2858

2859

            // We called request_delegate in session 0, we will be able to execute it starting from session 2

2860

1

            run_to_session(2);

2861

1

            // Anyone can execute pending operations for anyone else

2862

1

            assert_ok!(PooledStaking::execute_pending_operations(

2863

1

                origin_of(BOB.into()),

2864

1

                vec![PendingOperationQuery {

2865

1

                    delegator: ALICE.into(),

2866

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2867

1

                        candidate: ALICE.into(),

2868

1

                        at: 0,

2869

1

2870

1

}]

2871

1

            ),);

2872

1

});

2873

1

2874

2875

#[test]

2876

1

fn test_staking_join_execute_bad_origin() {

2877

1

    ExtBuilder::default()

2878

1

        .with_balances(vec![

2879

1

            // Alice gets 10k extra tokens for her mapping deposit

2880

1

            (AccountId::from(ALICE), 210_000 * UNIT),

2881

1

            (AccountId::from(BOB), 100_000 * UNIT),

2882

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2883

1

            (AccountId::from(DAVE), 100_000 * UNIT),

2884

1

])

2885

1

        .with_collators(vec![

2886

1

            (AccountId::from(ALICE), 210 * UNIT),

2887

1

            (AccountId::from(BOB), 100 * UNIT),

2888

1

            (AccountId::from(CHARLIE), 100 * UNIT),

2889

1

            (AccountId::from(DAVE), 100 * UNIT),

2890

1

])

2891

1

        .with_empty_parachains(vec![1001, 1002])

2892

1

        .build()

2893

1

        .execute_with(|| {

2894

1

            run_to_block(2);

2895

1

2896

1

            let stake = 10 * MinimumSelfDelegation::get();

2897

1

            assert_ok!(PooledStaking::request_delegate(

2898

1

                origin_of(ALICE.into()),

2899

1

                ALICE.into(),

2900

1

                TargetPool::AutoCompounding,

2901

1

                stake

2902

1

));

2903

2904

            // Immediately after joining, Alice is the top candidate

2905

1

            let eligible_candidates =

2906

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

2907

1

            assert_eq!(

2908

1

                eligible_candidates,

2909

1

                vec![EligibleCandidate {

2910

1

                    candidate: ALICE.into(),

2911

1

                    stake

2912

1

}]

2913

1

);

2914

2915

            // We called request_delegate in session 0, we will be able to execute it starting from session 2

2916

1

            run_to_session(2);

2917

1

            assert_noop!(

2918

1

                PooledStaking::execute_pending_operations(

2919

1

                    root_origin(),

2920

1

                    vec![PendingOperationQuery {

2921

1

                        delegator: ALICE.into(),

2922

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

2923

1

                            candidate: ALICE.into(),

2924

1

                            at: 0,

2925

1

2926

1

}]

2927

1

),

2928

1

                BadOrigin,

2929

1

);

2930

1

});

2931

1

2932

2933

struct A {

2934

    delegator: AccountId,

2935

    candidate: AccountId,

2936

    target_pool: TargetPool,

2937

    stake: u128,

2938

2939

2940

// Setup test environment with provided delegations already being executed. Input function f gets executed at start session 2

2941

9

fn setup_staking_join_and_execute<R>(ops: Vec<A>, f: impl FnOnce() -> R) {

2942

9

    ExtBuilder::default()

2943

9

        .with_balances(vec![

2944

9

            // Alice gets 10k extra tokens for her mapping deposit

2945

9

            (AccountId::from(ALICE), 210_000 * UNIT),

2946

9

            (AccountId::from(BOB), 100_000 * UNIT),

2947

9

            (AccountId::from(CHARLIE), 100_000 * UNIT),

2948

9

            (AccountId::from(DAVE), 100_000 * UNIT),

2949

9

])

2950

9

        .with_collators(vec![

2951

9

            (AccountId::from(ALICE), 210 * UNIT),

2952

9

            (AccountId::from(BOB), 100 * UNIT),

2953

9

            (AccountId::from(CHARLIE), 100 * UNIT),

2954

9

            (AccountId::from(DAVE), 100 * UNIT),

2955

9

])

2956

9

        .with_empty_parachains(vec![1001, 1002])

2957

9

        .build()

2958

9

        .execute_with(|| {

2959

9

            run_to_block(2);

2960

2961

9

            for op in ops.iter() {

2962

9

                assert_ok!(PooledStaking::request_delegate(

2963

9

                    origin_of(op.delegator.clone()),

2964

9

                    op.candidate.clone(),

2965

9

                    op.target_pool,

2966

9

                    op.stake,

2967

9

));

2968

2969

2970

            // We called request_delegate in session 0, we will be able to execute it starting from session 2

2971

9

            run_to_session(2);

2972

2973

9

            for op in ops.iter() {

2974

9

                let operation = match op.target_pool {

2975

9

                    TargetPool::AutoCompounding => PendingOperationKey::JoiningAutoCompounding {

2976

9

                        candidate: op.candidate.clone(),

2977

9

                        at: 0,

2978

9

},

2979

                    TargetPool::ManualRewards => PendingOperationKey::JoiningManualRewards {

2980

                        candidate: op.candidate.clone(),

2981

                        at: 0,

2982

},

2983

};

2984

2985

9

                assert_ok!(PooledStaking::execute_pending_operations(

2986

9

                    origin_of(op.delegator.clone()),

2987

9

                    vec![PendingOperationQuery {

2988

9

                        delegator: op.delegator.clone(),

2989

9

                        operation,

2990

9

}]

2991

9

));

2992

2993

2994

9

f()

2995

9

});

2996

9

2997

2998

#[test]

2999

1

fn test_staking_leave_exact_amount() {

3000

1

    setup_staking_join_and_execute(

3001

1

        vec![A {

3002

1

            delegator: ALICE.into(),

3003

1

            candidate: ALICE.into(),

3004

1

            target_pool: TargetPool::AutoCompounding,

3005

1

            stake: 10 * MinimumSelfDelegation::get(),

3006

1

}],

3007

1

        || {

3008

1

            let stake = 10 * MinimumSelfDelegation::get();

3009

1

            assert_ok!(PooledStaking::request_undelegate(

3010

1

                origin_of(ALICE.into()),

3011

1

                ALICE.into(),

3012

1

                TargetPool::AutoCompounding,

3013

1

                SharesOrStake::Stake(stake),

3014

1

));

3015

3016

            // Immediately after calling request_undelegate, Alice is no longer a candidate

3017

1

            let eligible_candidates =

3018

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3019

1

            assert_eq!(eligible_candidates, vec![]);

3020

1

},

3021

1

3022

1

3023

3024

#[test]

3025

1

fn test_staking_leave_bad_origin() {

3026

1

    setup_staking_join_and_execute(

3027

1

        vec![A {

3028

1

            delegator: ALICE.into(),

3029

1

            candidate: ALICE.into(),

3030

1

            target_pool: TargetPool::AutoCompounding,

3031

1

            stake: 10 * MinimumSelfDelegation::get(),

3032

1

}],

3033

1

        || {

3034

1

            let stake = 10 * MinimumSelfDelegation::get();

3035

1

            assert_noop!(

3036

1

                PooledStaking::request_undelegate(

3037

1

                    root_origin(),

3038

1

                    ALICE.into(),

3039

1

                    TargetPool::AutoCompounding,

3040

1

                    SharesOrStake::Stake(stake),

3041

1

),

3042

1

                BadOrigin

3043

1

);

3044

1

},

3045

1

3046

1

3047

3048

#[test]

3049

1

fn test_staking_leave_more_than_allowed() {

3050

1

    setup_staking_join_and_execute(

3051

1

        vec![A {

3052

1

            delegator: ALICE.into(),

3053

1

            candidate: ALICE.into(),

3054

1

            target_pool: TargetPool::AutoCompounding,

3055

1

            stake: 10 * MinimumSelfDelegation::get(),

3056

1

}],

3057

1

        || {

3058

1

            let stake = 10 * MinimumSelfDelegation::get();

3059

1

            assert_noop!(

3060

1

                PooledStaking::request_undelegate(

3061

1

                    origin_of(ALICE.into()),

3062

1

                    ALICE.into(),

3063

1

                    TargetPool::AutoCompounding,

3064

1

                    SharesOrStake::Stake(stake + 1 * MinimumSelfDelegation::get()),

3065

1

),

3066

1

                pallet_pooled_staking::Error::<Runtime>::MathUnderflow,

3067

1

);

3068

1

},

3069

1

);

3070

1

3071

3072

#[test]

3073

1

fn test_staking_leave_in_separate_transactions() {

3074

1

    let stake = 10 * MinimumSelfDelegation::get();

3075

1

3076

1

    setup_staking_join_and_execute(

3077

1

        vec![A {

3078

1

            delegator: ALICE.into(),

3079

1

            candidate: ALICE.into(),

3080

1

            target_pool: TargetPool::AutoCompounding,

3081

1

            stake,

3082

1

}],

3083

1

        || {

3084

1

            let half_stake = stake / 2;

3085

1

            assert_ok!(PooledStaking::request_undelegate(

3086

1

                origin_of(ALICE.into()),

3087

1

                ALICE.into(),

3088

1

                TargetPool::AutoCompounding,

3089

1

                SharesOrStake::Stake(half_stake),

3090

1

));

3091

3092

            // Alice is still a valid candidate, now with less stake

3093

1

            let eligible_candidates =

3094

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3095

1

            let remaining_stake = stake - half_stake;

3096

1

            assert_eq!(

3097

1

                eligible_candidates,

3098

1

                vec![EligibleCandidate {

3099

1

                    candidate: ALICE.into(),

3100

1

                    stake: remaining_stake,

3101

1

}],

3102

1

);

3103

3104

1

            assert_ok!(PooledStaking::request_undelegate(

3105

1

                origin_of(ALICE.into()),

3106

1

                ALICE.into(),

3107

1

                TargetPool::AutoCompounding,

3108

1

                SharesOrStake::Stake(remaining_stake),

3109

1

));

3110

3111

            // Unstaked remaining stake, so no longer a valid candidate

3112

1

            let eligible_candidates =

3113

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3114

1

            assert_eq!(eligible_candidates, vec![],);

3115

1

},

3116

1

);

3117

1

3118

3119

#[test]

3120

1

fn test_staking_leave_all_except_some_dust() {

3121

1

    let stake = 10 * MinimumSelfDelegation::get();

3122

1

3123

1

    setup_staking_join_and_execute(

3124

1

        vec![A {

3125

1

            delegator: ALICE.into(),

3126

1

            candidate: ALICE.into(),

3127

1

            target_pool: TargetPool::AutoCompounding,

3128

1

            stake,

3129

1

}],

3130

1

        || {

3131

1

            let dust = MinimumSelfDelegation::get() / 2;

3132

1

            assert_ok!(PooledStaking::request_undelegate(

3133

1

                origin_of(ALICE.into()),

3134

1

                ALICE.into(),

3135

1

                TargetPool::AutoCompounding,

3136

1

                SharesOrStake::Stake(stake - dust),

3137

1

));

3138

3139

            // Alice still has some stake left, but not enough to reach MinimumSelfDelegation

3140

1

            assert_eq!(

3141

1

                pallet_pooled_staking::Pools::<Runtime>::get(

3142

1

                    AccountId::from(ALICE),

3143

1

                    PoolsKey::CandidateTotalStake

3144

1

),

3145

1

                dust,

3146

1

);

3147

3148

1

            let eligible_candidates =

3149

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3150

1

            assert_eq!(eligible_candidates, vec![],);

3151

3152

            // Leave with remaining stake

3153

1

            assert_ok!(PooledStaking::request_undelegate(

3154

1

                origin_of(ALICE.into()),

3155

1

                ALICE.into(),

3156

1

                TargetPool::AutoCompounding,

3157

1

                SharesOrStake::Stake(dust),

3158

1

));

3159

3160

            // Alice has no more stake left

3161

1

            assert_eq!(

3162

1

                pallet_pooled_staking::Pools::<Runtime>::get(

3163

1

                    AccountId::from(ALICE),

3164

1

                    PoolsKey::CandidateTotalStake

3165

1

),

3166

1

0,

3167

1

);

3168

1

},

3169

1

);

3170

1

3171

3172

#[test]

3173

1

fn test_staking_leave_execute_before_time() {

3174

1

    let stake = 10 * MinimumSelfDelegation::get();

3175

1

3176

1

    setup_staking_join_and_execute(

3177

1

        vec![A {

3178

1

            delegator: ALICE.into(),

3179

1

            candidate: ALICE.into(),

3180

1

            target_pool: TargetPool::AutoCompounding,

3181

1

            stake,

3182

1

}],

3183

1

        || {

3184

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

3185

1

            let at = Session::current_index();

3186

1

            assert_ok!(PooledStaking::request_undelegate(

3187

1

                origin_of(ALICE.into()),

3188

1

                ALICE.into(),

3189

1

                TargetPool::AutoCompounding,

3190

1

                SharesOrStake::Stake(stake),

3191

1

));

3192

3193

            // Request undelegate does not change account balance

3194

1

            assert_eq!(

3195

1

                balance_before,

3196

1

                System::account(AccountId::from(ALICE)).data.free

3197

1

);

3198

3199

            // We called request_delegate in session 0, we will be able to execute it starting from session 2

3200

1

            let start_of_session_4 = session_to_block(4);

3201

1

            // Session 4 starts at block 1200, but run_to_session runs to block 1201, so subtract 2 here to go to 1999

3202

1

            run_to_block(start_of_session_4 - 2);

3203

1

3204

1

            assert_noop!(

3205

1

                PooledStaking::execute_pending_operations(

3206

1

                    origin_of(ALICE.into()),

3207

1

                    vec![PendingOperationQuery {

3208

1

                        delegator: ALICE.into(),

3209

1

                        operation: PendingOperationKey::Leaving {

3210

1

                            candidate: ALICE.into(),

3211

1

at,

3212

1

3213

1

}]

3214

1

),

3215

1

                pallet_pooled_staking::Error::<Runtime>::RequestCannotBeExecuted(0)

3216

1

);

3217

1

},

3218

1

);

3219

1

3220

3221

#[test]

3222

1

fn test_staking_leave_execute_any_origin() {

3223

1

    let stake = 10 * MinimumSelfDelegation::get();

3224

1

3225

1

    setup_staking_join_and_execute(

3226

1

        vec![A {

3227

1

            delegator: ALICE.into(),

3228

1

            candidate: ALICE.into(),

3229

1

            target_pool: TargetPool::AutoCompounding,

3230

1

            stake,

3231

1

}],

3232

1

        || {

3233

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

3234

1

            let at = Session::current_index();

3235

1

            assert_ok!(PooledStaking::request_undelegate(

3236

1

                origin_of(ALICE.into()),

3237

1

                ALICE.into(),

3238

1

                TargetPool::AutoCompounding,

3239

1

                SharesOrStake::Stake(stake),

3240

1

));

3241

3242

            // Request undelegate does not change account balance

3243

1

            assert_eq!(

3244

1

                balance_before,

3245

1

                System::account(AccountId::from(ALICE)).data.free

3246

1

);

3247

3248

1

            run_to_session(4);

3249

1

3250

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

3251

1

3252

1

            assert_ok!(PooledStaking::execute_pending_operations(

3253

1

                // Any signed origin can execute this, the stake will go to Alice account

3254

1

                origin_of(BOB.into()),

3255

1

                vec![PendingOperationQuery {

3256

1

                    delegator: ALICE.into(),

3257

1

                    operation: PendingOperationKey::Leaving {

3258

1

                        candidate: ALICE.into(),

3259

1

at,

3260

1

3261

1

}]

3262

1

            ),);

3263

3264

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

3265

1

            assert_eq!(balance_after - balance_before, stake);

3266

1

},

3267

1

);

3268

1

3269

3270

#[test]

3271

1

fn test_staking_leave_execute_bad_origin() {

3272

1

    let stake = 10 * MinimumSelfDelegation::get();

3273

1

3274

1

    setup_staking_join_and_execute(

3275

1

        vec![A {

3276

1

            delegator: ALICE.into(),

3277

1

            candidate: ALICE.into(),

3278

1

            target_pool: TargetPool::AutoCompounding,

3279

1

            stake,

3280

1

}],

3281

1

        || {

3282

1

            let at = Session::current_index();

3283

1

            assert_ok!(PooledStaking::request_undelegate(

3284

1

                origin_of(ALICE.into()),

3285

1

                ALICE.into(),

3286

1

                TargetPool::AutoCompounding,

3287

1

                SharesOrStake::Stake(stake),

3288

1

));

3289

3290

1

            run_to_session(4);

3291

1

3292

1

            assert_noop!(

3293

1

                PooledStaking::execute_pending_operations(

3294

1

                    root_origin(),

3295

1

                    vec![PendingOperationQuery {

3296

1

                        delegator: ALICE.into(),

3297

1

                        operation: PendingOperationKey::Leaving {

3298

1

                            candidate: ALICE.into(),

3299

1

at,

3300

1

3301

1

}]

3302

1

),

3303

1

                BadOrigin

3304

1

);

3305

1

},

3306

1

);

3307

1

3308

3309

#[test]

3310

1

fn test_staking_swap() {

3311

1

    setup_staking_join_and_execute(

3312

1

        vec![A {

3313

1

            delegator: ALICE.into(),

3314

1

            candidate: ALICE.into(),

3315

1

            target_pool: TargetPool::AutoCompounding,

3316

1

            stake: 10 * MinimumSelfDelegation::get(),

3317

1

}],

3318

1

        || {

3319

1

            let stake = 10 * MinimumSelfDelegation::get();

3320

1

            assert_ok!(PooledStaking::swap_pool(

3321

1

                origin_of(ALICE.into()),

3322

1

                ALICE.into(),

3323

1

                TargetPool::AutoCompounding,

3324

1

                SharesOrStake::Stake(stake),

3325

1

));

3326

3327

1

            assert_eq!(

3328

1

                PooledStaking::computed_stake(

3329

1

                    ALICE.into(),

3330

1

                    ALICE.into(),

3331

1

                    AllTargetPool::AutoCompounding

3332

1

),

3333

1

                Some(0u32.into())

3334

1

);

3335

1

            assert_eq!(

3336

1

                PooledStaking::computed_stake(

3337

1

                    ALICE.into(),

3338

1

                    ALICE.into(),

3339

1

                    AllTargetPool::ManualRewards

3340

1

),

3341

1

                Some(stake)

3342

1

);

3343

3344

1

            assert_ok!(PooledStaking::swap_pool(

3345

1

                origin_of(ALICE.into()),

3346

1

                ALICE.into(),

3347

1

                TargetPool::ManualRewards,

3348

1

                SharesOrStake::Stake(stake),

3349

1

));

3350

3351

1

            assert_eq!(

3352

1

                PooledStaking::computed_stake(

3353

1

                    ALICE.into(),

3354

1

                    ALICE.into(),

3355

1

                    AllTargetPool::AutoCompounding

3356

1

),

3357

1

                Some(stake)

3358

1

);

3359

1

            assert_eq!(

3360

1

                PooledStaking::computed_stake(

3361

1

                    ALICE.into(),

3362

1

                    ALICE.into(),

3363

1

                    AllTargetPool::ManualRewards

3364

1

),

3365

1

                Some(0u32.into())

3366

1

);

3367

1

},

3368

1

3369

1

3370

3371

#[test]

3372

1

fn test_pallet_session_takes_validators_from_invulnerables_and_staking() {

3373

1

    // Alice, Bob, Charlie are invulnerables

3374

1

    // Alice, Dave are in pallet_staking

3375

1

    // Expected collators are Alice, Bob, Charlie, Dave

3376

1

    ExtBuilder::default()

3377

1

        .with_balances(vec![

3378

1

            // Alice gets 10k extra tokens for her mapping deposit

3379

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3380

1

            (AccountId::from(BOB), 100_000 * UNIT),

3381

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3382

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3383

1

])

3384

1

        .with_collators(vec![

3385

1

            (AccountId::from(ALICE), 210 * UNIT),

3386

1

            (AccountId::from(BOB), 100 * UNIT),

3387

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3388

1

])

3389

1

        .with_empty_parachains(vec![1001, 1002])

3390

1

        .build()

3391

1

        .execute_with(|| {

3392

1

            run_to_block(2);

3393

1

3394

1

            let stake = 10 * MinimumSelfDelegation::get();

3395

1

3396

1

            assert_ok!(PooledStaking::request_delegate(

3397

1

                origin_of(ALICE.into()),

3398

1

                ALICE.into(),

3399

1

                TargetPool::AutoCompounding,

3400

1

                stake,

3401

1

));

3402

3403

            // Register Dave in pallet_session (invulnerables are automatically registered)

3404

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3405

1

            assert_ok!(Session::set_keys(

3406

1

                origin_of(DAVE.into()),

3407

1

                crate::SessionKeys {

3408

1

                    nimbus: dave_account_id,

3409

1

},

3410

1

                vec![]

3411

1

));

3412

3413

1

            assert_ok!(PooledStaking::request_delegate(

3414

1

                origin_of(DAVE.into()),

3415

1

                DAVE.into(),

3416

1

                TargetPool::AutoCompounding,

3417

1

                stake,

3418

1

));

3419

3420

1

            let eligible_candidates =

3421

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3422

1

            assert_eq!(

3423

1

                eligible_candidates,

3424

1

                vec![

3425

1

                    EligibleCandidate {

3426

1

                        candidate: ALICE.into(),

3427

1

                        stake

3428

1

},

3429

1

                    EligibleCandidate {

3430

1

                        candidate: DAVE.into(),

3431

1

                        stake

3432

1

},

3433

1

3434

1

);

3435

3436

1

            assert_eq!(

3437

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3438

1

                vec![

3439

1

                    AccountId::from(ALICE),

3440

1

                    AccountId::from(BOB),

3441

1

                    AccountId::from(CHARLIE),

3442

1

3443

1

);

3444

3445

            // Need to trigger new session to update pallet_session

3446

1

            run_to_session(2);

3447

1

3448

1

            assert_eq!(

3449

1

                Session::validators(),

3450

1

                vec![

3451

1

                    AccountId::from(ALICE),

3452

1

                    AccountId::from(BOB),

3453

1

                    AccountId::from(CHARLIE),

3454

1

                    AccountId::from(DAVE),

3455

1

3456

1

);

3457

1

});

3458

1

3459

3460

#[test]

3461

1

fn test_pallet_session_limits_num_validators() {

3462

1

    // Set max_collators = 2, now only the first 2 invulnerables are valid collators

3463

1

    ExtBuilder::default()

3464

1

        .with_balances(vec![

3465

1

            // Alice gets 10k extra tokens for her mapping deposit

3466

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3467

1

            (AccountId::from(BOB), 100_000 * UNIT),

3468

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3469

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3470

1

])

3471

1

        .with_collators(vec![

3472

1

            (AccountId::from(ALICE), 210 * UNIT),

3473

1

            (AccountId::from(BOB), 100 * UNIT),

3474

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3475

1

])

3476

1

        .with_empty_parachains(vec![1001, 1002])

3477

1

        .with_config(pallet_configuration::HostConfiguration {

3478

1

            max_collators: 2,

3479

1

            min_orchestrator_collators: 2,

3480

1

            max_orchestrator_collators: 2,

3481

1

            collators_per_container: 2,

3482

1

            full_rotation_period: 24,

3483

1

            ..Default::default()

3484

1

})

3485

1

        .build()

3486

1

        .execute_with(|| {

3487

1

            run_to_block(2);

3488

1

3489

1

            let stake = 10 * MinimumSelfDelegation::get();

3490

1

3491

1

            assert_ok!(PooledStaking::request_delegate(

3492

1

                origin_of(ALICE.into()),

3493

1

                ALICE.into(),

3494

1

                TargetPool::AutoCompounding,

3495

1

                stake,

3496

1

));

3497

3498

            // Register Dave in pallet_session (invulnerables are automatically registered)

3499

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3500

1

            assert_ok!(Session::set_keys(

3501

1

                origin_of(DAVE.into()),

3502

1

                crate::SessionKeys {

3503

1

                    nimbus: dave_account_id,

3504

1

},

3505

1

                vec![]

3506

1

));

3507

3508

1

            assert_ok!(PooledStaking::request_delegate(

3509

1

                origin_of(DAVE.into()),

3510

1

                DAVE.into(),

3511

1

                TargetPool::AutoCompounding,

3512

1

                stake,

3513

1

));

3514

3515

1

            let eligible_candidates =

3516

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3517

1

            assert_eq!(

3518

1

                eligible_candidates,

3519

1

                vec![

3520

1

                    EligibleCandidate {

3521

1

                        candidate: ALICE.into(),

3522

1

                        stake

3523

1

},

3524

1

                    EligibleCandidate {

3525

1

                        candidate: DAVE.into(),

3526

1

                        stake

3527

1

},

3528

1

3529

1

);

3530

3531

1

            assert_eq!(

3532

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3533

1

                vec![

3534

1

                    AccountId::from(ALICE),

3535

1

                    AccountId::from(BOB),

3536

1

                    AccountId::from(CHARLIE),

3537

1

3538

1

);

3539

3540

            // Need to trigger new session to update pallet_session

3541

1

            run_to_session(2);

3542

1

3543

1

            assert_eq!(

3544

1

                Session::validators(),

3545

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3546

1

);

3547

1

});

3548

1

3549

3550

#[test]

3551

1

fn test_pallet_session_limits_num_validators_from_staking() {

3552

1

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

3553

1

    ExtBuilder::default()

3554

1

        .with_balances(vec![

3555

1

            // Alice gets 10k extra tokens for her mapping deposit

3556

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3557

1

            (AccountId::from(BOB), 100_000 * UNIT),

3558

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3559

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3560

1

])

3561

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3562

1

        .with_empty_parachains(vec![1001, 1002])

3563

1

        .with_config(pallet_configuration::HostConfiguration {

3564

1

            max_collators: 2,

3565

1

            min_orchestrator_collators: 2,

3566

1

            max_orchestrator_collators: 2,

3567

1

            collators_per_container: 2,

3568

1

            full_rotation_period: 24,

3569

1

            ..Default::default()

3570

1

})

3571

1

        .build()

3572

1

        .execute_with(|| {

3573

1

            run_to_block(2);

3574

1

3575

1

            let stake = 10 * MinimumSelfDelegation::get();

3576

1

3577

1

            // Register accounts in pallet_session (invulnerables are automatically registered)

3578

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3579

1

            assert_ok!(Session::set_keys(

3580

1

                origin_of(BOB.into()),

3581

1

                crate::SessionKeys {

3582

1

                    nimbus: bob_account_id,

3583

1

},

3584

1

                vec![]

3585

1

));

3586

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

3587

1

            assert_ok!(Session::set_keys(

3588

1

                origin_of(CHARLIE.into()),

3589

1

                crate::SessionKeys {

3590

1

                    nimbus: charlie_account_id,

3591

1

},

3592

1

                vec![]

3593

1

));

3594

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3595

1

            assert_ok!(Session::set_keys(

3596

1

                origin_of(DAVE.into()),

3597

1

                crate::SessionKeys {

3598

1

                    nimbus: dave_account_id,

3599

1

},

3600

1

                vec![]

3601

1

));

3602

3603

1

            assert_ok!(PooledStaking::request_delegate(

3604

1

                origin_of(BOB.into()),

3605

1

                BOB.into(),

3606

1

                TargetPool::AutoCompounding,

3607

1

                stake,

3608

1

));

3609

3610

1

            assert_ok!(PooledStaking::request_delegate(

3611

1

                origin_of(CHARLIE.into()),

3612

1

                CHARLIE.into(),

3613

1

                TargetPool::AutoCompounding,

3614

1

                stake,

3615

1

));

3616

3617

1

            assert_ok!(PooledStaking::request_delegate(

3618

1

                origin_of(DAVE.into()),

3619

1

                DAVE.into(),

3620

1

                TargetPool::AutoCompounding,

3621

1

                stake,

3622

1

));

3623

3624

1

            let eligible_candidates =

3625

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3626

1

            assert_eq!(

3627

1

                eligible_candidates,

3628

1

                vec![

3629

1

                    EligibleCandidate {

3630

1

                        candidate: BOB.into(),

3631

1

                        stake

3632

1

},

3633

1

                    EligibleCandidate {

3634

1

                        candidate: CHARLIE.into(),

3635

1

                        stake

3636

1

},

3637

1

                    EligibleCandidate {

3638

1

                        candidate: DAVE.into(),

3639

1

                        stake

3640

1

},

3641

1

3642

1

);

3643

3644

1

            assert_eq!(

3645

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3646

1

                vec![AccountId::from(ALICE),]

3647

1

);

3648

3649

            // Need to trigger new session to update pallet_session

3650

1

            run_to_session(2);

3651

1

3652

1

            assert_eq!(

3653

1

                Session::validators(),

3654

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3655

1

);

3656

1

});

3657

1

3658

3659

#[test]

3660

1

fn test_reward_to_staking_candidate() {

3661

1

    // Alice, Bob, Charlie are invulnerables

3662

1

    ExtBuilder::default()

3663

1

        .with_balances(vec![

3664

1

            // Alice gets 10k extra tokens for her mapping deposit

3665

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3666

1

            (AccountId::from(BOB), 100_000 * UNIT),

3667

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3668

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3669

1

])

3670

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3671

1

        .with_empty_parachains(vec![1001, 1002])

3672

1

        .build()

3673

1

        .execute_with(|| {

3674

1

            run_to_block(2);

3675

1

3676

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3677

1

            assert_ok!(Session::set_keys(

3678

1

                origin_of(DAVE.into()),

3679

1

                crate::SessionKeys {

3680

1

                    nimbus: dave_account_id,

3681

1

},

3682

1

                vec![]

3683

1

));

3684

3685

            // We make delegations to DAVE so that she is an elligible candidate.

3686

3687

1

            let stake = 10 * MinimumSelfDelegation::get();

3688

1

3689

1

            assert_ok!(PooledStaking::request_delegate(

3690

1

                origin_of(DAVE.into()),

3691

1

                DAVE.into(),

3692

1

                TargetPool::ManualRewards,

3693

1

                stake,

3694

1

));

3695

1

            assert_ok!(PooledStaking::request_delegate(

3696

1

                origin_of(BOB.into()),

3697

1

                DAVE.into(),

3698

1

                TargetPool::AutoCompounding,

3699

1

                stake,

3700

1

));

3701

3702

            // wait few sessions for the request to be executable

3703

1

            run_to_session(3u32);

3704

1

            assert_ok!(PooledStaking::execute_pending_operations(

3705

1

                origin_of(ALICE.into()),

3706

1

                vec![

3707

1

                    PendingOperationQuery {

3708

1

                        delegator: DAVE.into(),

3709

1

                        operation: PendingOperationKey::JoiningManualRewards {

3710

1

                            candidate: DAVE.into(),

3711

1

                            at: 0

3712

1

3713

1

},

3714

1

                    PendingOperationQuery {

3715

1

                        delegator: BOB.into(),

3716

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3717

1

                            candidate: DAVE.into(),

3718

1

                            at: 0

3719

1

3720

1

3721

1

3722

1

));

3723

3724

            // wait for next session so that DAVE is elected

3725

1

            run_to_session(4u32);

3726

1

3727

1

            assert_eq!(

3728

1

                Session::validators(),

3729

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

3730

1

);

3731

3732

1

            let account: AccountId = DAVE.into();

3733

1

            let balance_before = System::account(account.clone()).data.free;

3734

1

            let summary = (0..100)

3735

1

                .find_map(|_| {

3736

1

                    let summary = run_block();

3737

1

                    if summary.author_id == DAVE.into() {

3738

1

                        Some(summary)

3739

                    } else {

3740

                        None

3741

3742

1

})

3743

1

                .unwrap_or_else(|| panic!("DAVE doesn't seem to author any blocks"));

3744

1

            let balance_after = System::account(account).data.free;

3745

1

3746

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3747

1

            // rewards are shared between orchestrator and registered paras

3748

1

            let orchestrator_rewards = all_rewards / 3;

3749

1

            let candidate_rewards = RewardsCollatorCommission::get() * orchestrator_rewards;

3750

1

3751

1

            assert_eq!(

3752

1

                candidate_rewards,

3753

1

                balance_after - balance_before,

3754

                "dave should get the correct reward portion"

3755

);

3756

1

});

3757

1

3758

3759

#[test]

3760

1

fn test_reward_to_invulnerable() {

3761

1

    // Alice, Bob, Charlie are invulnerables

3762

1

    ExtBuilder::default()

3763

1

        .with_balances(vec![

3764

1

            // Alice gets 10k extra tokens for her mapping deposit

3765

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3766

1

            (AccountId::from(BOB), 100_000 * UNIT),

3767

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3768

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3769

1

])

3770

1

        .with_collators(vec![

3771

1

            (AccountId::from(ALICE), 210 * UNIT),

3772

1

            (AccountId::from(BOB), 100 * UNIT),

3773

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3774

1

])

3775

1

        .with_empty_parachains(vec![1001, 1002])

3776

1

        .build()

3777

1

        .execute_with(|| {

3778

1

            run_to_block(2);

3779

1

3780

1

            // We make delegations to ALICE so that she is an elligible candidate.

3781

1

            // However since she is an invulnerable she should get all the

3782

1

            // rewards.

3783

1

3784

1

            let stake = 10 * MinimumSelfDelegation::get();

3785

1

3786

1

            assert_ok!(PooledStaking::request_delegate(

3787

1

                origin_of(ALICE.into()),

3788

1

                ALICE.into(),

3789

1

                TargetPool::ManualRewards,

3790

1

                stake,

3791

1

));

3792

1

            assert_ok!(PooledStaking::request_delegate(

3793

1

                origin_of(BOB.into()),

3794

1

                ALICE.into(),

3795

1

                TargetPool::AutoCompounding,

3796

1

                stake,

3797

1

));

3798

3799

            // wait few sessions for the request to be executable

3800

1

            run_to_session(3u32);

3801

1

            assert_ok!(PooledStaking::execute_pending_operations(

3802

1

                origin_of(ALICE.into()),

3803

1

                vec![

3804

1

                    PendingOperationQuery {

3805

1

                        delegator: ALICE.into(),

3806

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3807

1

                            candidate: ALICE.into(),

3808

1

                            at: 0

3809

1

3810

1

},

3811

1

                    PendingOperationQuery {

3812

1

                        delegator: BOB.into(),

3813

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3814

1

                            candidate: ALICE.into(),

3815

1

                            at: 0

3816

1

3817

1

3818

1

3819

1

));

3820

3821

            // wait for next session so that ALICE is elected

3822

1

            run_to_session(4u32);

3823

1

3824

1

            let account: AccountId = ALICE.into();

3825

1

            let balance_before = System::account(account.clone()).data.free;

3826

1

3827

1

            let summary = (0..100)

3828

2

                .find_map(|_| {

3829

2

                    let summary = run_block();

3830

2

                    if summary.author_id == ALICE.into() {

3831

1

                        Some(summary)

3832

                    } else {

3833

1

                        None

3834

3835

2

})

3836

1

                .unwrap_or_else(|| panic!("ALICE doesn't seem to author any blocks"));

3837

1

3838

1

            let balance_after = System::account(account).data.free;

3839

1

3840

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3841

1

            // rewards are shared between orchestrator and registered paras

3842

1

            let orchestrator_rewards = all_rewards / 3;

3843

1

            assert_eq!(

3844

1

                orchestrator_rewards,

3845

1

                balance_after - balance_before,

3846

                "alice should get the correct reward portion"

3847

);

3848

1

});

3849

1

3850

3851

#[test]

3852

1

fn test_reward_to_invulnerable_with_key_change() {

3853

1

    ExtBuilder::default()

3854

1

        .with_balances(vec![

3855

1

            // Alice gets 10k extra tokens for her mapping deposit

3856

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3857

1

            (AccountId::from(BOB), 100_000 * UNIT),

3858

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3859

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3860

1

])

3861

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3862

1

        .with_empty_parachains(vec![1001, 1002])

3863

1

        .build()

3864

1

        .execute_with(|| {

3865

1

            run_to_block(2);

3866

1

3867

1

            run_to_session(2u32);

3868

1

3869

1

            // change key, this should be reflected 2 sessions afterward

3870

1

            let alice_new_key = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3871

1

            assert_ok!(Session::set_keys(

3872

1

                origin_of(ALICE.into()),

3873

1

                crate::SessionKeys {

3874

1

                    nimbus: alice_new_key,

3875

1

},

3876

1

                vec![]

3877

1

));

3878

3879

1

            run_to_session(4u32);

3880

1

3881

1

            let account: AccountId = ALICE.into();

3882

1

            let balance_before = System::account(account.clone()).data.free;

3883

1

3884

1

            let summary = run_block();

3885

1

            assert_eq!(summary.author_id, ALICE.into());

3886

3887

1

            let balance_after = System::account(account).data.free;

3888

1

3889

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3890

1

            // rewards are shared between orchestrator and registered paras

3891

1

            let orchestrator_rewards = all_rewards / 3;

3892

1

            assert_eq!(

3893

1

                orchestrator_rewards,

3894

1

                balance_after - balance_before,

3895

                "alice should get the correct reward portion"

3896

);

3897

1

});

3898

1

3899

3900

#[test]

3901

1

fn test_migration_config_add_parachain_percentage() {

3902

1

    ExtBuilder::default().build().execute_with(|| {

3903

        const CONFIGURATION_ACTIVE_CONFIG_KEY: &[u8] =

3904

            &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385");

3905

        const CONFIGURATION_PENDING_CONFIGS_KEY: &[u8] =

3906

            &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22d53b4123b2e186e07fb7bad5dda5f55c0");

3907

3908

        // Modify active config

3909

1

        frame_support::storage::unhashed::put_raw(

3910

1

            CONFIGURATION_ACTIVE_CONFIG_KEY,

3911

1

            &HostConfigurationV2 {

3912

1

                max_collators: 5,

3913

1

                min_orchestrator_collators: 2,

3914

1

                max_orchestrator_collators: 1,

3915

1

                collators_per_container: 3,

3916

1

                full_rotation_period: 4,

3917

1

                collators_per_parathread: 2,

3918

1

                parathreads_per_collator: 1,

3919

1

                target_container_chain_fullness: Perbill::from_percent(45),

3920

1

3921

1

            .encode(),

3922

1

);

3923

1

        // Modify pending configs

3924

1

        frame_support::storage::unhashed::put_raw(

3925

1

            CONFIGURATION_PENDING_CONFIGS_KEY,

3926

1

            &vec![

3927

1

3928

1

                    1234u32,

3929

1

                    HostConfigurationV2 {

3930

1

                        max_collators: 1,

3931

1

                        min_orchestrator_collators: 4,

3932

1

                        max_orchestrator_collators: 45,

3933

1

                        collators_per_container: 5,

3934

1

                        full_rotation_period: 1,

3935

1

                        collators_per_parathread: 1,

3936

1

                        parathreads_per_collator: 1,

3937

1

                        target_container_chain_fullness: Perbill::from_percent(65),

3938

1

},

3939

1

),

3940

1

3941

1

                    5678u32,

3942

1

                    HostConfigurationV2 {

3943

1

                        max_collators: 1,

3944

1

                        min_orchestrator_collators: 4,

3945

1

                        max_orchestrator_collators: 45,

3946

1

                        collators_per_container: 5,

3947

1

                        full_rotation_period: 1,

3948

1

                        collators_per_parathread: 1,

3949

1

                        parathreads_per_collator: 1,

3950

1

                        target_container_chain_fullness: Perbill::from_percent(65),

3951

1

},

3952

1

),

3953

1

3954

1

            .encode(),

3955

1

);

3956

1

3957

1

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

3958

1

        migration.migrate(Default::default());

3959

1

3960

1

        let expected_active = pallet_configuration::HostConfiguration {

3961

1

            max_collators: 5,

3962

1

            min_orchestrator_collators: 2,

3963

1

            max_orchestrator_collators: 1,

3964

1

            collators_per_container: 3,

3965

1

            full_rotation_period: 4,

3966

1

            collators_per_parathread: 2,

3967

1

            parathreads_per_collator: 1,

3968

1

            target_container_chain_fullness: Perbill::from_percent(45),

3969

1

            ..Default::default()

3970

1

};

3971

1

        assert_eq!(Configuration::config(), expected_active);

3972

3973

1

        let expected_pending = vec![

3974

1

3975

1

                1234u32,

3976

1

                pallet_configuration::HostConfiguration {

3977

1

                    max_collators: 1,

3978

1

                    min_orchestrator_collators: 4,

3979

1

                    max_orchestrator_collators: 45,

3980

1

                    collators_per_container: 5,

3981

1

                    full_rotation_period: 1,

3982

1

                    collators_per_parathread: 1,

3983

1

                    parathreads_per_collator: 1,

3984

1

                    target_container_chain_fullness: Perbill::from_percent(65),

3985

1

                    ..Default::default()

3986

1

},

3987

1

),

3988

1

3989

1

                5678u32,

3990

1

                pallet_configuration::HostConfiguration {

3991

1

                    max_collators: 1,

3992

1

                    min_orchestrator_collators: 4,

3993

1

                    max_orchestrator_collators: 45,

3994

1

                    collators_per_container: 5,

3995

1

                    full_rotation_period: 1,

3996

1

                    collators_per_parathread: 1,

3997

1

                    parathreads_per_collator: 1,

3998

1

                    target_container_chain_fullness: Perbill::from_percent(65),

3999

1

                    ..Default::default()

4000

1

},

4001

1

),

4002

1

];

4003

1

        assert_eq!(Configuration::pending_configs(), expected_pending);

4004

1

});

4005

1

4006

4007

#[test]

4008

1

fn test_migration_config_full_rotation_period() {

4009

1

    ExtBuilder::default()

4010

1

        .build()

4011

1

        .execute_with(|| {

4012

            const CONFIGURATION_ACTIVE_CONFIG_KEY: &[u8] =

4013

                &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385");

4014

            const CONFIGURATION_PENDING_CONFIGS_KEY: &[u8] =

4015

                &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22d53b4123b2e186e07fb7bad5dda5f55c0");

4016

4017

            // Modify active config

4018

1

            frame_support::storage::unhashed::put_raw(CONFIGURATION_ACTIVE_CONFIG_KEY, &hex_literal::hex!("6300000002000000050000000200000000000000"));

4019

1

            // Modify pending configs

4020

1

            frame_support::storage::unhashed::put_raw(CONFIGURATION_PENDING_CONFIGS_KEY, &hex_literal::hex!("08b10800006300000002000000050000000200000000000000b20800006400000002000000050000000200000000000000"));

4021

1

4022

1

            let migration = MigrateConfigurationParathreads::<Runtime>(Default::default());

4023

1

            migration.migrate(Default::default());

4024

1

4025

1

            let expected_active = pallet_configuration::HostConfiguration {

4026

1

                max_collators: 99,

4027

1

                min_orchestrator_collators: 2,

4028

1

                max_orchestrator_collators: 5,

4029

1

                collators_per_container: 2,

4030

1

                full_rotation_period: 0,

4031

1

                ..Default::default()

4032

1

};

4033

1

            assert_eq!(Configuration::config(), expected_active);

4034

4035

1

            let expected_pending = vec![

4036

1

4037

1

                    2225,

4038

1

                    pallet_configuration::HostConfiguration {

4039

1

                        max_collators: 99,

4040

1

                        min_orchestrator_collators: 2,

4041

1

                        max_orchestrator_collators: 5,

4042

1

                        collators_per_container: 2,

4043

1

                        full_rotation_period: 0,

4044

1

                        ..Default::default()

4045

1

},

4046

1

),

4047

1

4048

1

                    2226,

4049

1

                    pallet_configuration::HostConfiguration {

4050

1

                        max_collators: 100,

4051

1

                        min_orchestrator_collators: 2,

4052

1

                        max_orchestrator_collators: 5,

4053

1

                        collators_per_container: 2,

4054

1

                        full_rotation_period: 0,

4055

1

                        ..Default::default()

4056

1

},

4057

1

),

4058

1

];

4059

1

            assert_eq!(Configuration::pending_configs(), expected_pending);

4060

1

});

4061

1

4062

4063

#[test]

4064

1

fn test_migration_registrar_pending_verification() {

4065

1

    ExtBuilder::default().build().execute_with(|| {

4066

        const REGISTRAR_PENDING_VERIFICATION_KEY: &[u8] =

4067

            &hex_literal::hex!("3fba98689ebed1138735e0e7a5a790ab57a35de516113188134ad8e43c6d55ec");

4068

4069

        // Modify active config

4070

1

        let para_ids: Vec<ParaId> = vec![2000.into(), 2001.into(), 2002.into(), 3000.into()];

4071

1

        frame_support::storage::unhashed::put(REGISTRAR_PENDING_VERIFICATION_KEY, &para_ids);

4072

1

4073

1

        let migration = RegistrarPendingVerificationValueToMap::<Runtime>(Default::default());

4074

1

        migration.migrate(Default::default());

4075

1

4076

1

        let empty_key =

4077

1

            frame_support::storage::unhashed::get_raw(REGISTRAR_PENDING_VERIFICATION_KEY);

4078

1

        assert_eq!(empty_key, None);

4079

4080

5

        for para_id in para_ids {

4081

4

            let exists_in_map =

4082

4

                pallet_registrar::PendingVerification::<Runtime>::get(para_id).is_some();

4083

4

            assert!(

4084

4

                exists_in_map,

4085

                "After migration, para id {:?} does not exist in storage map",

4086

                para_id

4087

);

4088

4089

1

});

4090

1

4091

4092

#[test]

4093

1

fn test_collator_assignment_gives_priority_to_invulnerables() {

4094

1

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

4095

1

    ExtBuilder::default()

4096

1

        .with_balances(vec![

4097

1

            // Alice gets 10k extra tokens for her mapping deposit

4098

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4099

1

            (AccountId::from(BOB), 100_000 * UNIT),

4100

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4101

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4102

1

])

4103

1

        .with_collators(vec![

4104

1

            (AccountId::from(ALICE), 210 * UNIT),

4105

1

            (AccountId::from(DAVE), 100 * UNIT),

4106

1

])

4107

1

        .with_empty_parachains(vec![1001, 1002])

4108

1

        .build()

4109

1

        .execute_with(|| {

4110

1

            run_to_block(2);

4111

1

4112

1

            let stake = 10 * MinimumSelfDelegation::get();

4113

1

4114

1

            // Register accounts in pallet_session (invulnerables are automatically registered)

4115

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4116

1

            assert_ok!(Session::set_keys(

4117

1

                origin_of(BOB.into()),

4118

1

                crate::SessionKeys {

4119

1

                    nimbus: bob_account_id,

4120

1

},

4121

1

                vec![]

4122

1

));

4123

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

4124

1

            assert_ok!(Session::set_keys(

4125

1

                origin_of(CHARLIE.into()),

4126

1

                crate::SessionKeys {

4127

1

                    nimbus: charlie_account_id,

4128

1

},

4129

1

                vec![]

4130

1

));

4131

4132

1

            assert_ok!(PooledStaking::request_delegate(

4133

1

                origin_of(BOB.into()),

4134

1

                BOB.into(),

4135

1

                TargetPool::AutoCompounding,

4136

1

                stake,

4137

1

));

4138

1

            assert_ok!(PooledStaking::request_delegate(

4139

1

                origin_of(CHARLIE.into()),

4140

1

                CHARLIE.into(),

4141

1

                TargetPool::AutoCompounding,

4142

1

                stake,

4143

1

));

4144

4145

1

            let eligible_candidates =

4146

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

4147

1

            assert_eq!(

4148

1

                eligible_candidates,

4149

1

                vec![

4150

1

                    EligibleCandidate {

4151

1

                        candidate: BOB.into(),

4152

1

                        stake

4153

1

},

4154

1

                    EligibleCandidate {

4155

1

                        candidate: CHARLIE.into(),

4156

1

                        stake

4157

1

},

4158

1

4159

1

);

4160

4161

1

            assert_eq!(

4162

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

4163

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

4164

1

);

4165

4166

1

            set_parachain_inherent_data_random_seed([1; 32]);

4167

1

            run_block();

4168

1

4169

1

            // Need to trigger new session to update pallet_session

4170

1

            run_to_session(2);

4171

1

4172

1

            assert_eq!(

4173

1

                Session::validators(),

4174

1

                vec![

4175

1

                    AccountId::from(ALICE),

4176

1

                    AccountId::from(DAVE),

4177

1

                    AccountId::from(BOB),

4178

1

                    AccountId::from(CHARLIE)

4179

1

4180

1

);

4181

4182

            // Need to trigger full rotation to ensure invulnerables are assigned

4183

1

            let rotation_period = Configuration::config().full_rotation_period;

4184

1

            run_to_session(rotation_period);

4185

1

4186

1

            assert!(

4187

1

                CollatorAssignment::collator_container_chain()

4188

1

                    .orchestrator_chain

4189

1

                    .contains(&AccountId::from(ALICE)),

4190

                "CollatorAssignment did not give priority to invulnerable ALICE: {:?}",

4191

                CollatorAssignment::collator_container_chain()

4192

);

4193

4194

1

            assert!(

4195

1

                CollatorAssignment::collator_container_chain()

4196

1

                    .orchestrator_chain

4197

1

                    .contains(&AccountId::from(DAVE)),

4198

                "CollatorAssignment did not give priority to invulnerable DAVE: {:?}",

4199

                CollatorAssignment::collator_container_chain()

4200

);

4201

1

});

4202

1

4203

4204

#[test]

4205

1

fn test_can_buy_credits_before_registering_para() {

4206

1

    ExtBuilder::default()

4207

1

        .with_balances(vec![

4208

1

            // Alice gets 10k extra tokens for her mapping deposit

4209

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4210

1

            (AccountId::from(BOB), 100_000 * UNIT),

4211

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4212

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4213

1

])

4214

1

        .with_collators(vec![

4215

1

            (AccountId::from(ALICE), 210 * UNIT),

4216

1

            (AccountId::from(BOB), 100 * UNIT),

4217

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4218

1

            (AccountId::from(DAVE), 100 * UNIT),

4219

1

])

4220

1

        .build()

4221

1

        .execute_with(|| {

4222

1

            run_to_block(2);

4223

1

4224

1

            // Try to buy the maximum amount of credits

4225

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4226

1

4227

1

            assert_ok!(ServicesPayment::purchase_credits(

4228

1

                origin_of(ALICE.into()),

4229

1

                1001.into(),

4230

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4231

1

));

4232

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4233

1

4234

1

            // Now parachain tank should have this amount

4235

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4236

1

                .data

4237

1

                .free;

4238

1

4239

1

            assert_eq!(

4240

1

                balance_tank,

4241

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4242

1

);

4243

4244

1

            let expected_cost = block_credits_to_required_balance(u32::MAX, 1001.into());

4245

1

            assert_eq!(balance_before - balance_after, expected_cost);

4246

1

});

4247

1

4248

4249

#[test]

4250

1

fn test_cannot_mark_valid_para_with_no_bootnodes() {

4251

1

    ExtBuilder::default()

4252

1

        .with_balances(vec![

4253

1

            // Alice gets 10k extra tokens for her mapping deposit

4254

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4255

1

            (AccountId::from(BOB), 100_000 * UNIT),

4256

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4257

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4258

1

])

4259

1

        .with_collators(vec![

4260

1

            (AccountId::from(ALICE), 210 * UNIT),

4261

1

            (AccountId::from(BOB), 100 * UNIT),

4262

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4263

1

            (AccountId::from(DAVE), 100 * UNIT),

4264

1

])

4265

1

        .build()

4266

1

        .execute_with(|| {

4267

1

            run_to_block(2);

4268

1

            assert_ok!(Registrar::register(

4269

1

                origin_of(ALICE.into()),

4270

1

                1001.into(),

4271

1

                empty_genesis_data(),

4272

1

                None

4273

1

));

4274

1

            assert_noop!(

4275

1

                Registrar::mark_valid_for_collating(root_origin(), 1001.into()),

4276

1

                pallet_data_preservers::Error::<Runtime>::NoBootNodes,

4277

1

);

4278

1

});

4279

1

4280

4281

#[test]

4282

1

fn test_can_buy_credits_before_registering_para_and_receive_free_credits() {

4283

1

    ExtBuilder::default()

4284

1

        .with_balances(vec![

4285

1

            // Alice gets 10k extra tokens for her mapping deposit

4286

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4287

1

            (AccountId::from(BOB), 100_000 * UNIT),

4288

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4289

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4290

1

])

4291

1

        .with_collators(vec![

4292

1

            (AccountId::from(ALICE), 210 * UNIT),

4293

1

            (AccountId::from(BOB), 100 * UNIT),

4294

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4295

1

            (AccountId::from(DAVE), 100 * UNIT),

4296

1

])

4297

1

        .build()

4298

1

        .execute_with(|| {

4299

1

            run_to_block(2);

4300

1

4301

1

            // Try to buy (MaxCreditsStored - 1) credits

4302

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4303

1

            assert_ok!(ServicesPayment::purchase_credits(

4304

1

                origin_of(ALICE.into()),

4305

1

                1001.into(),

4306

1

                block_credits_to_required_balance(

4307

1

                    crate::FreeBlockProductionCredits::get() - 1,

4308

1

                    1001.into()

4309

1

4310

1

));

4311

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4312

1

4313

1

            // Now parachain tank should have this amount

4314

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4315

1

                .data

4316

1

                .free;

4317

1

4318

1

            assert_eq!(

4319

1

                balance_tank,

4320

1

                block_credits_to_required_balance(

4321

1

                    crate::FreeBlockProductionCredits::get() - 1,

4322

1

                    1001.into()

4323

1

4324

1

);

4325

4326

1

            let expected_cost = block_credits_to_required_balance(

4327

1

                crate::FreeBlockProductionCredits::get() - 1,

4328

1

                1001.into(),

4329

1

);

4330

1

            assert_eq!(balance_before - balance_after, expected_cost);

4331

4332

            // Now register para

4333

1

            assert_ok!(Registrar::register(

4334

1

                origin_of(ALICE.into()),

4335

1

                1001.into(),

4336

1

                empty_genesis_data(),

4337

1

                None

4338

1

));

4339

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4340

1

            assert_ok!(Registrar::mark_valid_for_collating(

4341

1

                root_origin(),

4342

1

                1001.into()

4343

1

));

4344

4345

            // We received aññ free credits, because we cannot have more than MaxCreditsStored

4346

1

            let credits =

4347

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4348

1

                    .unwrap_or_default();

4349

1

            assert_eq!(credits, crate::FreeBlockProductionCredits::get());

4350

1

});

4351

1

4352

4353

#[test]

4354

1

fn test_deregister_and_register_again_does_not_give_free_credits() {

4355

1

    ExtBuilder::default()

4356

1

        .with_balances(vec![

4357

1

            // Alice gets 10k extra tokens for her mapping deposit

4358

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4359

1

            (AccountId::from(BOB), 100_000 * UNIT),

4360

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4361

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4362

1

])

4363

1

        .with_collators(vec![

4364

1

            (AccountId::from(ALICE), 210 * UNIT),

4365

1

            (AccountId::from(BOB), 100 * UNIT),

4366

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4367

1

            (AccountId::from(DAVE), 100 * UNIT),

4368

1

])

4369

1

        .build()

4370

1

        .execute_with(|| {

4371

1

            run_to_block(2);

4372

1

4373

1

            // Register

4374

1

            assert_ok!(Registrar::register(

4375

1

                origin_of(ALICE.into()),

4376

1

                1001.into(),

4377

1

                empty_genesis_data(),

4378

1

                None

4379

1

            ),);

4380

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4381

1

            assert_ok!(Registrar::mark_valid_for_collating(

4382

1

                root_origin(),

4383

1

                1001.into()

4384

1

            ),);

4385

            // We received free credits

4386

1

            let credits =

4387

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4388

1

                    .unwrap_or_default();

4389

1

            assert_eq!(credits, crate::FreeBlockProductionCredits::get());

4390

            // Deregister after 1 session

4391

1

            run_to_session(1);

4392

1

            assert_ok!(Registrar::deregister(root_origin(), 1001.into()), ());

4393

4394

1

            run_to_session(3);

4395

1

            let credits_before_2nd_register =

4396

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4397

1

                    .unwrap_or_default();

4398

1

            // We spent some credits because this container chain had collators for 1 session

4399

1

            assert_ne!(

4400

1

                credits_before_2nd_register,

4401

1

                crate::FreeBlockProductionCredits::get()

4402

1

);

4403

            // Register again

4404

1

            assert_ok!(Registrar::register(

4405

1

                origin_of(ALICE.into()),

4406

1

                1001.into(),

4407

1

                empty_genesis_data(),

4408

1

                None

4409

1

            ),);

4410

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4411

1

            assert_ok!(Registrar::mark_valid_for_collating(

4412

1

                root_origin(),

4413

1

                1001.into()

4414

1

            ),);

4415

            // No more free credits

4416

1

            let credits =

4417

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4418

1

                    .unwrap_or_default();

4419

1

            assert_eq!(credits, credits_before_2nd_register);

4420

1

});

4421

1

4422

4423

#[test]

4424

1

fn test_sudo_can_register_foreign_assets_and_manager_change_paremeters() {

4425

1

    ExtBuilder::default()

4426

1

        .with_balances(vec![

4427

1

            // Alice gets 10k extra tokens for her mapping deposit

4428

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4429

1

            (AccountId::from(BOB), 100_000 * UNIT),

4430

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4431

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4432

1

])

4433

1

        .with_collators(vec![

4434

1

            (AccountId::from(ALICE), 210 * UNIT),

4435

1

            (AccountId::from(BOB), 100 * UNIT),

4436

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4437

1

            (AccountId::from(DAVE), 100 * UNIT),

4438

1

])

4439

1

4440

1

        .build()

4441

1

        .execute_with(|| {

4442

1

4443

1

            // We register the asset with Alice as manager

4444

1

            assert_ok!(ForeignAssetsCreator::create_foreign_asset(root_origin(), Location::parent(), 1, AccountId::from(ALICE), true, 1), ());

4445

1

            assert_eq!(ForeignAssetsCreator::foreign_asset_for_id(1), Some(Location::parent()));

4446

1

            assert_eq!(ForeignAssetsCreator::asset_id_for_foreign(Location::parent()), Some(1));

4447

4448

            // Alice now can change parameters like metadata from the asset

4449

1

            assert_ok!(ForeignAssets::set_metadata(origin_of(ALICE.into()), 1, b"xcDot".to_vec(), b"xcDot".to_vec(), 12));

4450

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::name(1),  b"xcDot".to_vec());

4451

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::symbol(1),  b"xcDot".to_vec());

4452

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::decimals(1),  12);

4453

4454

            // Any other person cannot do this

4455

1

            assert_noop!(

4456

1

                ForeignAssets::set_metadata(origin_of(BOB.into()), 1, b"dummy".to_vec(), b"dummy".to_vec(), 12),

4457

1

                pallet_assets::Error::<Runtime, Instance1>::NoPermission

4458

1

);

4459

4460

            // Alice now can mint

4461

1

            assert_ok!(ForeignAssets::mint(origin_of(ALICE.into()), 1, AccountId::from(BOB).into(), 1000));

4462

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::total_issuance(1),  1000);

4463

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::balance(1, &AccountId::from(BOB)),  1000);

4464

1

});

4465

1

4466

4467

#[test]

4468

1

fn test_assets_cannot_be_created_from_signed_origins() {

4469

1

    ExtBuilder::default()

4470

1

        .with_balances(vec![

4471

1

            // Alice gets 10k extra tokens for her mapping deposit

4472

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4473

1

            (AccountId::from(BOB), 100_000 * UNIT),

4474

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4475

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4476

1

])

4477

1

        .with_collators(vec![

4478

1

            (AccountId::from(ALICE), 210 * UNIT),

4479

1

            (AccountId::from(BOB), 100 * UNIT),

4480

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4481

1

            (AccountId::from(DAVE), 100 * UNIT),

4482

1

])

4483

1

        .build()

4484

1

        .execute_with(|| {

4485

1

            // We try to register the asset with Alice as origin

4486

1

            // Any other person cannot do this

4487

1

            assert_noop!(

4488

1

                ForeignAssetsCreator::create_foreign_asset(

4489

1

                    origin_of(ALICE.into()),

4490

1

                    Location::parent(),

4491

1

1,

4492

1

                    AccountId::from(ALICE),

4493

1

                    true,

4494

1

4495

1

),

4496

1

                BadOrigin

4497

1

);

4498

4499

1

            assert_noop!(

4500

1

                ForeignAssets::create(origin_of(ALICE.into()), 1, AccountId::from(ALICE).into(), 1),

4501

1

                BadOrigin

4502

1

);

4503

1

});

4504

1

4505

4506

#[test]

4507

1

fn test_asset_rate_can_be_set_from_sudo_but_not_from_signed() {

4508

1

    ExtBuilder::default()

4509

1

        .with_balances(vec![

4510

1

            // Alice gets 10k extra tokens for her mapping deposit

4511

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4512

1

            (AccountId::from(BOB), 100_000 * UNIT),

4513

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4514

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4515

1

])

4516

1

        .with_collators(vec![

4517

1

            (AccountId::from(ALICE), 210 * UNIT),

4518

1

            (AccountId::from(BOB), 100 * UNIT),

4519

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4520

1

            (AccountId::from(DAVE), 100 * UNIT),

4521

1

])

4522

1

        .build()

4523

1

        .execute_with(|| {

4524

1

            // We try to set the rate from non-sudo

4525

1

            assert_noop!(

4526

1

                AssetRate::create(origin_of(ALICE.into()), Box::new(1), FixedU128::from_u32(1)),

4527

1

                BadOrigin

4528

1

);

4529

4530

            // We try to set the rate from sudo

4531

1

            assert_ok!(AssetRate::create(

4532

1

                root_origin(),

4533

1

                Box::new(1),

4534

1

                FixedU128::from_u32(1)

4535

1

));

4536

4537

1

            assert_eq!(

4538

1

                pallet_asset_rate::ConversionRateToNative::<Runtime>::get(1),

4539

1

                Some(FixedU128::from_u32(1))

4540

1

);

4541

1

});

4542

1

4543

4544

#[test]

4545

1

fn test_division_by_0() {

4546

1

    ExtBuilder::default()

4547

1

        .with_balances(vec![

4548

1

            // Alice gets 10k extra tokens for her mapping deposit

4549

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4550

1

            (AccountId::from(BOB), 100_000 * UNIT),

4551

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4552

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4553

1

])

4554

1

        .with_collators(vec![

4555

1

            (AccountId::from(ALICE), 210 * UNIT),

4556

1

            (AccountId::from(BOB), 100 * UNIT),

4557

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4558

1

            (AccountId::from(DAVE), 100 * UNIT),

4559

1

])

4560

1

        .build()

4561

1

        .execute_with(|| {

4562

1

            // We try to set 0 rate to make sure we dont overflow

4563

1

            assert_ok!(AssetRate::create(

4564

1

                root_origin(),

4565

1

                Box::new(1),

4566

1

                FixedU128::from_u32(0)

4567

1

));

4568

4569

            use frame_support::traits::tokens::ConversionToAssetBalance;

4570

1

            let balance = AssetRate::to_asset_balance(1, 1);

4571

1

            assert!(balance.is_err());

4572

1

});

4573

1

4574

4575

#[test]

4576

1

fn test_register_parathread() {

4577

1

    ExtBuilder::default()

4578

1

        .with_balances(vec![

4579

1

            // Alice gets 10k extra tokens for her mapping deposit

4580

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4581

1

            (AccountId::from(BOB), 100_000 * UNIT),

4582

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4583

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4584

1

])

4585

1

        .with_collators(vec![

4586

1

            (AccountId::from(ALICE), 210 * UNIT),

4587

1

            (AccountId::from(BOB), 100 * UNIT),

4588

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4589

1

            (AccountId::from(DAVE), 100 * UNIT),

4590

1

])

4591

1

        .build()

4592

1

        .execute_with(|| {

4593

1

            run_to_block(2);

4594

1

4595

1

            // Register

4596

1

            assert_ok!(Registrar::register_parathread(

4597

1

                origin_of(ALICE.into()),

4598

1

                3001.into(),

4599

1

                SlotFrequency { min: 1, max: 1 },

4600

1

                empty_genesis_data(),

4601

1

                None

4602

1

));

4603

1

            set_dummy_boot_node(origin_of(ALICE.into()), 3001.into());

4604

1

            assert_ok!(Registrar::mark_valid_for_collating(

4605

1

                root_origin(),

4606

1

                3001.into()

4607

1

));

4608

4609

1

            run_to_session(2);

4610

1

            let assignment = CollatorAssignment::collator_container_chain();

4611

1

            assert_eq!(

4612

1

                assignment.container_chains[&ParaId::from(3001)],

4613

1

                vec![CHARLIE.into()]

4614

1

);

4615

1

});

4616

1

4617

4618

#[test]

4619

1

fn test_register_parathread_genesis() {

4620

1

    let parathread_params = tp_traits::ParathreadParams {

4621

1

        slot_frequency: SlotFrequency { min: 1, max: 1 },

4622

1

};

4623

1

    ExtBuilder::default()

4624

1

        .with_balances(vec![

4625

1

            // Alice gets 10k extra tokens for her mapping deposit

4626

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4627

1

            (AccountId::from(BOB), 100_000 * UNIT),

4628

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4629

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4630

1

])

4631

1

        .with_collators(vec![

4632

1

            (AccountId::from(ALICE), 210 * UNIT),

4633

1

            (AccountId::from(BOB), 100 * UNIT),

4634

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4635

1

            (AccountId::from(DAVE), 100 * UNIT),

4636

1

])

4637

1

        .with_para_ids(vec![ParaRegistrationParams {

4638

1

            para_id: 3001,

4639

1

            genesis_data: empty_genesis_data(),

4640

1

            block_production_credits: u32::MAX,

4641

1

            collator_assignment_credits: u32::MAX,

4642

1

            parathread_params: Some(parathread_params.clone()),

4643

1

}])

4644

1

        .build()

4645

1

        .execute_with(|| {

4646

1

            run_to_block(2);

4647

1

4648

1

            assert_eq!(Registrar::registered_para_ids(), vec![3001.into()]);

4649

1

            assert_eq!(

4650

1

                pallet_registrar::ParathreadParams::<Runtime>::get(ParaId::from(3001)),

4651

1

                Some(parathread_params)

4652

1

);

4653

4654

1

            let assignment = CollatorAssignment::collator_container_chain();

4655

1

            assert_eq!(

4656

1

                assignment.container_chains[&ParaId::from(3001)],

4657

1

                vec![CHARLIE.into()]

4658

1

);

4659

1

});

4660

1

4661

4662

#[test]

4663

1

fn test_ed_plus_block_credit_session_purchase_works() {

4664

1

    ExtBuilder::default()

4665

1

        .with_balances(vec![

4666

1

            // Alice gets 10k extra tokens for her mapping deposit

4667

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4668

1

            (AccountId::from(BOB), 100_000 * UNIT),

4669

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4670

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4671

1

])

4672

1

        .with_collators(vec![

4673

1

            (AccountId::from(ALICE), 210 * UNIT),

4674

1

            (AccountId::from(BOB), 100 * UNIT),

4675

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4676

1

            (AccountId::from(DAVE), 100 * UNIT),

4677

1

])

4678

1

        .build()

4679

1

        .execute_with(|| {

4680

1

            run_to_block(2);

4681

1

            // Assert current slot gets updated

4682

1

            assert_eq!(current_slot(), 1u64);

4683

1

            assert!(current_author() == AccountId::from(BOB));

4684

4685

            // Alice and Bob collate in our chain

4686

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4687

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4688

1

4689

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4690

4691

1

            assert_ok!(Registrar::register(

4692

1

                origin_of(ALICE.into()),

4693

1

                1001.into(),

4694

1

                empty_genesis_data(),

4695

1

                None

4696

1

));

4697

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4698

1

            assert_ok!(Registrar::mark_valid_for_collating(

4699

1

                root_origin(),

4700

1

                1001.into()

4701

1

));

4702

            // Need to reset credits to 0 because now parachains are given free credits on register

4703

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4704

1

                root_origin(),

4705

1

                1001.into(),

4706

1

4707

1

));

4708

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

4709

1

                + crate::EXISTENTIAL_DEPOSIT;

4710

1

4711

1

            // Fill the tank

4712

1

            assert_ok!(ServicesPayment::purchase_credits(

4713

1

                origin_of(ALICE.into()),

4714

1

                1001.into(),

4715

1

                credits_1001

4716

1

));

4717

4718

            // Assignment should happen after 2 sessions

4719

1

            run_to_session(1u32);

4720

1

            let assignment = CollatorAssignment::collator_container_chain();

4721

1

            assert!(assignment.container_chains.is_empty());

4722

1

            run_to_session(2u32);

4723

1

            // Charlie and Dave should be assigned to para 1001

4724

1

            let assignment = CollatorAssignment::collator_container_chain();

4725

1

            assert_eq!(

4726

1

                assignment.container_chains[&1001u32.into()],

4727

1

                vec![CHARLIE.into(), DAVE.into()]

4728

1

);

4729

4730

            // Simulate block inclusion from container chain 1001

4731

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4732

1

            let slot: u64 = 5;

4733

1

            let s = ParaHeaderSproofBuilderItem {

4734

1

                para_id: 1001.into(),

4735

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4736

1

                    parent_hash: Default::default(),

4737

1

                    number: 1,

4738

1

                    state_root: Default::default(),

4739

1

                    extrinsics_root: Default::default(),

4740

1

                    digest: sp_runtime::generic::Digest {

4741

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4742

1

},

4743

1

}),

4744

1

};

4745

1

4746

1

            sproof.items.push(s);

4747

1

            set_author_noting_inherent_data(sproof);

4748

1

4749

1

            run_block();

4750

1

4751

1

            // After this it should not be assigned anymore, since credits are not payable

4752

1

            run_to_session(3u32);

4753

1

            // Nobody should be assigned to para 1001

4754

1

            let assignment = CollatorAssignment::collator_container_chain();

4755

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4756

1

});

4757

1

4758

4759

#[test]

4760

1

fn test_ed_plus_block_credit_session_minus_1_purchase_fails() {

4761

1

    ExtBuilder::default()

4762

1

        .with_balances(vec![

4763

1

            // Alice gets 10k extra tokens for her mapping deposit

4764

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4765

1

            (AccountId::from(BOB), 100_000 * UNIT),

4766

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4767

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4768

1

])

4769

1

        .with_collators(vec![

4770

1

            (AccountId::from(ALICE), 210 * UNIT),

4771

1

            (AccountId::from(BOB), 100 * UNIT),

4772

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4773

1

            (AccountId::from(DAVE), 100 * UNIT),

4774

1

])

4775

1

        .build()

4776

1

        .execute_with(|| {

4777

1

            run_to_block(2);

4778

1

            // Assert current slot gets updated

4779

1

            assert_eq!(current_slot(), 1u64);

4780

1

            assert!(current_author() == AccountId::from(BOB));

4781

4782

            // Alice and Bob collate in our chain

4783

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4784

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4785

1

4786

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4787

4788

1

            assert_ok!(Registrar::register(

4789

1

                origin_of(ALICE.into()),

4790

1

                1001.into(),

4791

1

                empty_genesis_data(),

4792

1

                None

4793

1

));

4794

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4795

1

            assert_ok!(Registrar::mark_valid_for_collating(

4796

1

                root_origin(),

4797

1

                1001.into()

4798

1

));

4799

            // Need to reset credits to 0 because now parachains are given free credits on register

4800

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4801

1

                root_origin(),

4802

1

                1001.into(),

4803

1

4804

1

));

4805

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

4806

1

                + crate::EXISTENTIAL_DEPOSIT

4807

1

                - 1;

4808

1

4809

1

            // Fill the tank

4810

1

            assert_ok!(ServicesPayment::purchase_credits(

4811

1

                origin_of(ALICE.into()),

4812

1

                1001.into(),

4813

1

                credits_1001

4814

1

));

4815

4816

            // Assignment should happen after 2 sessions

4817

1

            run_to_session(1u32);

4818

1

            let assignment = CollatorAssignment::collator_container_chain();

4819

1

            assert!(assignment.container_chains.is_empty());

4820

1

            run_to_session(2u32);

4821

1

            // Charlie and Dave should not be assigned to para 1001

4822

1

            let assignment = CollatorAssignment::collator_container_chain();

4823

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4824

1

});

4825

1

4826

4827

#[test]

4828

1

fn test_reassignment_ed_plus_two_block_credit_session_purchase_works() {

4829

1

    ExtBuilder::default()

4830

1

        .with_balances(vec![

4831

1

            // Alice gets 10k extra tokens for her mapping deposit

4832

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4833

1

            (AccountId::from(BOB), 100_000 * UNIT),

4834

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4835

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4836

1

])

4837

1

        .with_collators(vec![

4838

1

            (AccountId::from(ALICE), 210 * UNIT),

4839

1

            (AccountId::from(BOB), 100 * UNIT),

4840

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4841

1

            (AccountId::from(DAVE), 100 * UNIT),

4842

1

])

4843

1

        .build()

4844

1

        .execute_with(|| {

4845

1

            run_to_block(2);

4846

1

            // Assert current slot gets updated

4847

1

            assert_eq!(current_slot(), 1u64);

4848

1

            assert!(current_author() == AccountId::from(BOB));

4849

4850

            // Alice and Bob collate in our chain

4851

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4852

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4853

1

4854

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4855

4856

1

            assert_ok!(Registrar::register(

4857

1

                origin_of(ALICE.into()),

4858

1

                1001.into(),

4859

1

                empty_genesis_data(),

4860

1

                None

4861

1

));

4862

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4863

1

            assert_ok!(Registrar::mark_valid_for_collating(

4864

1

                root_origin(),

4865

1

                1001.into()

4866

1

));

4867

            // Need to reset credits to 0 because now parachains are given free credits on register

4868

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4869

1

                root_origin(),

4870

1

                1001.into(),

4871

1

4872

1

));

4873

            // On reassignment the blocks credits needed should be enough for the current session and the next one

4874

1

            let credits_1001 =

4875

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into())

4876

1

                    + crate::EXISTENTIAL_DEPOSIT;

4877

1

4878

1

            // Fill the tank

4879

1

            assert_ok!(ServicesPayment::purchase_credits(

4880

1

                origin_of(ALICE.into()),

4881

1

                1001.into(),

4882

1

                credits_1001

4883

1

));

4884

4885

            // Assignment should happen after 2 sessions

4886

1

            run_to_session(1u32);

4887

1

            let assignment = CollatorAssignment::collator_container_chain();

4888

1

            assert!(assignment.container_chains.is_empty());

4889

4890

1

            run_to_session(2u32);

4891

1

            // Charlie and Dave should be assigned to para 1001

4892

1

            let assignment = CollatorAssignment::collator_container_chain();

4893

1

            assert_eq!(

4894

1

                assignment.container_chains[&1001u32.into()],

4895

1

                vec![CHARLIE.into(), DAVE.into()]

4896

1

);

4897

4898

            // Simulate block inclusion from container chain 1001

4899

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4900

1

            let slot: u64 = 5;

4901

1

            let s = ParaHeaderSproofBuilderItem {

4902

1

                para_id: 1001.into(),

4903

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4904

1

                    parent_hash: Default::default(),

4905

1

                    number: 1,

4906

1

                    state_root: Default::default(),

4907

1

                    extrinsics_root: Default::default(),

4908

1

                    digest: sp_runtime::generic::Digest {

4909

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4910

1

},

4911

1

}),

4912

1

};

4913

1

4914

1

            sproof.items.push(s);

4915

1

            set_author_noting_inherent_data(sproof);

4916

1

4917

1

            run_block();

4918

1

4919

1

            // Session 3 should still be assigned

4920

1

            run_to_session(3u32);

4921

1

            // Charlie and Dave should be assigned to para 1001

4922

1

            let assignment = CollatorAssignment::collator_container_chain();

4923

1

            assert_eq!(

4924

1

                assignment.container_chains[&1001u32.into()],

4925

1

                vec![CHARLIE.into(), DAVE.into()]

4926

1

);

4927

4928

            // After this it should not be assigned anymore, since credits are not payable

4929

1

            run_to_session(4u32);

4930

1

            // Nobody should be assigned to para 1001

4931

1

            let assignment = CollatorAssignment::collator_container_chain();

4932

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4933

1

});

4934

1

4935

4936

#[test]

4937

1

fn test_reassignment_ed_plus_two_block_credit_session_minus_1_purchase_fails() {

4938

1

    ExtBuilder::default()

4939

1

        .with_balances(vec![

4940

1

            // Alice gets 10k extra tokens for her mapping deposit

4941

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4942

1

            (AccountId::from(BOB), 100_000 * UNIT),

4943

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4944

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4945

1

])

4946

1

        .with_collators(vec![

4947

1

            (AccountId::from(ALICE), 210 * UNIT),

4948

1

            (AccountId::from(BOB), 100 * UNIT),

4949

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4950

1

            (AccountId::from(DAVE), 100 * UNIT),

4951

1

])

4952

1

        .build()

4953

1

        .execute_with(|| {

4954

1

            run_to_block(2);

4955

1

            // Assert current slot gets updated

4956

1

            assert_eq!(current_slot(), 1u64);

4957

1

            assert!(current_author() == AccountId::from(BOB));

4958

4959

            // Alice and Bob collate in our chain

4960

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4961

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4962

1

4963

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4964

4965

1

            assert_ok!(Registrar::register(

4966

1

                origin_of(ALICE.into()),

4967

1

                1001.into(),

4968

1

                empty_genesis_data(),

4969

1

                None

4970

1

));

4971

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4972

1

            assert_ok!(Registrar::mark_valid_for_collating(

4973

1

                root_origin(),

4974

1

                1001.into()

4975

1

));

4976

            // Need to reset credits to 0 because now parachains are given free credits on register

4977

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4978

1

                root_origin(),

4979

1

                1001.into(),

4980

1

4981

1

));

4982

1

            let credits_1001 =

4983

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into())

4984

1

                    + crate::EXISTENTIAL_DEPOSIT

4985

1

                    - 1;

4986

1

4987

1

            // Fill the tank

4988

1

            assert_ok!(ServicesPayment::purchase_credits(

4989

1

                origin_of(ALICE.into()),

4990

1

                1001.into(),

4991

1

                credits_1001

4992

1

));

4993

4994

            // Assignment should happen after 2 sessions

4995

1

            run_to_session(1u32);

4996

1

            let assignment = CollatorAssignment::collator_container_chain();

4997

1

            assert!(assignment.container_chains.is_empty());

4998

4999

1

            run_to_session(2u32);

5000

1

            // Charlie and Dave should be assigned to para 1001

5001

1

            let assignment = CollatorAssignment::collator_container_chain();

5002

1

            assert_eq!(

5003

1

                assignment.container_chains[&1001u32.into()],

5004

1

                vec![CHARLIE.into(), DAVE.into()]

5005

1

);

5006

5007

            // Simulate block inclusion from container chain 1001

5008

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

5009

1

            let slot: u64 = 5;

5010

1

            let s = ParaHeaderSproofBuilderItem {

5011

1

                para_id: 1001.into(),

5012

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

5013

1

                    parent_hash: Default::default(),

5014

1

                    number: 1,

5015

1

                    state_root: Default::default(),

5016

1

                    extrinsics_root: Default::default(),

5017

1

                    digest: sp_runtime::generic::Digest {

5018

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

5019

1

},

5020

1

}),

5021

1

};

5022

1

5023

1

            sproof.items.push(s);

5024

1

            set_author_noting_inherent_data(sproof);

5025

1

5026

1

            run_block();

5027

1

5028

1

            // After this it should not be assigned anymore, since credits are not payable

5029

1

            run_to_session(3u32);

5030

1

            // Nobody should be assigned to para 1001

5031

1

            let assignment = CollatorAssignment::collator_container_chain();

5032

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5033

1

});

5034

1

5035

5036

#[test]

5037

1

fn test_block_credits_with_purchase_can_be_combined() {

5038

1

    ExtBuilder::default()

5039

1

        .with_balances(vec![

5040

1

            // Alice gets 10k extra tokens for her mapping deposit

5041

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5042

1

            (AccountId::from(BOB), 100_000 * UNIT),

5043

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5044

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5045

1

])

5046

1

        .with_collators(vec![

5047

1

            (AccountId::from(ALICE), 210 * UNIT),

5048

1

            (AccountId::from(BOB), 100 * UNIT),

5049

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5050

1

            (AccountId::from(DAVE), 100 * UNIT),

5051

1

])

5052

1

        .build()

5053

1

        .execute_with(|| {

5054

1

            run_to_block(2);

5055

1

            // Assert current slot gets updated

5056

1

            assert_eq!(current_slot(), 1u64);

5057

1

            assert!(current_author() == AccountId::from(BOB));

5058

5059

            // Alice and Bob collate in our chain

5060

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5061

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5062

1

5063

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5064

5065

1

            assert_ok!(Registrar::register(

5066

1

                origin_of(ALICE.into()),

5067

1

                1001.into(),

5068

1

                empty_genesis_data(),

5069

1

                None

5070

1

));

5071

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5072

1

            assert_ok!(Registrar::mark_valid_for_collating(

5073

1

                root_origin(),

5074

1

                1001.into()

5075

1

));

5076

            // Need to reset credits to 0 because now parachains are given free credits on register

5077

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5078

1

                root_origin(),

5079

1

                1001.into(),

5080

1

                crate::Period::get()

5081

1

));

5082

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

5083

1

                + crate::EXISTENTIAL_DEPOSIT;

5084

1

5085

1

            // Fill the tank

5086

1

            assert_ok!(ServicesPayment::purchase_credits(

5087

1

                origin_of(ALICE.into()),

5088

1

                1001.into(),

5089

1

                credits_1001

5090

1

));

5091

5092

            // Assignment should happen after 2 sessions

5093

1

            run_to_session(1u32);

5094

1

            let assignment = CollatorAssignment::collator_container_chain();

5095

1

            assert!(assignment.container_chains.is_empty());

5096

1

            run_to_session(2u32);

5097

1

            // Charlie and Dave should be assigned to para 1001

5098

1

            let assignment = CollatorAssignment::collator_container_chain();

5099

1

            assert_eq!(

5100

1

                assignment.container_chains[&1001u32.into()],

5101

1

                vec![CHARLIE.into(), DAVE.into()]

5102

1

);

5103

1

});

5104

1

5105

#[test]

5106

1

fn stream_payment_works() {

5107

1

    ExtBuilder::default()

5108

1

        .with_balances(vec![

5109

1

            (AccountId::from(ALICE), 100_000 * UNIT),

5110

1

            (AccountId::from(BOB), 100_000 * UNIT),

5111

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5112

1

])

5113

1

        .with_collators(vec![

5114

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5115

1

            (AccountId::from(DAVE), 100 * UNIT),

5116

1

])

5117

1

        .build()

5118

1

        .execute_with(|| {

5119

            use pallet_stream_payment::{ChangeKind, StreamConfig};

5120

5121

1

            assert_ok!(StreamPayment::open_stream(

5122

1

                origin_of(ALICE.into()),

5123

1

                BOB.into(),

5124

1

                StreamConfig {

5125

1

                    rate: 2 * UNIT,

5126

1

                    asset_id: StreamPaymentAssetId::Native,

5127

1

                    time_unit: TimeUnit::BlockNumber,

5128

1

},

5129

1

                1_000 * UNIT,

5130

1

));

5131

5132

1

            run_block();

5133

1

5134

1

            assert_ok!(StreamPayment::perform_payment(origin_of(CHARLIE.into()), 0));

5135

1

            assert_eq!(

5136

1

                Balances::free_balance(AccountId::from(BOB)),

5137

1

                100_000 * UNIT + 2 * UNIT

5138

1

);

5139

5140

1

            assert_ok!(StreamPayment::request_change(

5141

1

                origin_of(ALICE.into()),

5142

1

0,

5143

1

                ChangeKind::Suggestion,

5144

1

                StreamConfig {

5145

1

                    rate: 1 * UNIT,

5146

1

                    asset_id: StreamPaymentAssetId::Native,

5147

1

                    time_unit: TimeUnit::BlockNumber,

5148

1

},

5149

1

                None,

5150

1

));

5151

5152

1

            assert_ok!(StreamPayment::accept_requested_change(

5153

1

                origin_of(BOB.into()),

5154

1

0,

5155

1

                1, // nonce

5156

1

                None,

5157

1

));

5158

5159

1

            run_block();

5160

1

5161

1

            assert_ok!(StreamPayment::close_stream(origin_of(BOB.into()), 0));

5162

5163

1

            assert_eq!(

5164

1

                Balances::free_balance(AccountId::from(BOB)),

5165

1

                100_000 * UNIT + 3 * UNIT

5166

1

);

5167

1

            assert_eq!(

5168

1

                Balances::free_balance(AccountId::from(ALICE)),

5169

1

                100_000 * UNIT - 3 * UNIT

5170

1

);

5171

1

});

5172

1

5173

5174

#[test]

5175

1

fn test_ed_plus_collator_assignment_session_purchase_works() {

5176

1

    ExtBuilder::default()

5177

1

        .with_balances(vec![

5178

1

            // Alice gets 10k extra tokens for her mapping deposit

5179

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5180

1

            (AccountId::from(BOB), 100_000 * UNIT),

5181

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5182

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5183

1

])

5184

1

        .with_collators(vec![

5185

1

            (AccountId::from(ALICE), 210 * UNIT),

5186

1

            (AccountId::from(BOB), 100 * UNIT),

5187

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5188

1

            (AccountId::from(DAVE), 100 * UNIT),

5189

1

])

5190

1

        .build()

5191

1

        .execute_with(|| {

5192

1

            run_to_block(2);

5193

1

            // Assert current slot gets updated

5194

1

            assert_eq!(current_slot(), 1u64);

5195

1

            assert!(current_author() == AccountId::from(BOB));

5196

5197

            // Alice and Bob collate in our chain

5198

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5199

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5200

1

5201

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5202

5203

1

            assert_ok!(Registrar::register(

5204

1

                origin_of(ALICE.into()),

5205

1

                1001.into(),

5206

1

                empty_genesis_data(),

5207

1

                None

5208

1

));

5209

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5210

1

            assert_ok!(Registrar::mark_valid_for_collating(

5211

1

                root_origin(),

5212

1

                1001.into()

5213

1

));

5214

            // Need to reset credits to 0 because now parachains are given free credits on register

5215

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5216

1

                root_origin(),

5217

1

                1001.into(),

5218

1

5219

1

));

5220

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5221

1

                + crate::EXISTENTIAL_DEPOSIT;

5222

1

5223

1

            // Fill the tank

5224

1

            assert_ok!(ServicesPayment::purchase_credits(

5225

1

                origin_of(ALICE.into()),

5226

1

                1001.into(),

5227

1

                credits_1001

5228

1

));

5229

5230

            // Assignment should happen after 2 sessions

5231

1

            run_to_session(1u32);

5232

1

            let assignment = CollatorAssignment::collator_container_chain();

5233

1

            assert!(assignment.container_chains.is_empty());

5234

1

            run_to_session(2u32);

5235

1

            // Charlie and Dave should be assigned to para 1001

5236

1

            let assignment = CollatorAssignment::collator_container_chain();

5237

1

            assert_eq!(

5238

1

                assignment.container_chains[&1001u32.into()],

5239

1

                vec![CHARLIE.into(), DAVE.into()]

5240

1

);

5241

5242

            // Simulate block inclusion from container chain 1001

5243

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

5244

1

            let slot: u64 = 5;

5245

1

            let s = ParaHeaderSproofBuilderItem {

5246

1

                para_id: 1001.into(),

5247

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

5248

1

                    parent_hash: Default::default(),

5249

1

                    number: 1,

5250

1

                    state_root: Default::default(),

5251

1

                    extrinsics_root: Default::default(),

5252

1

                    digest: sp_runtime::generic::Digest {

5253

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

5254

1

},

5255

1

}),

5256

1

};

5257

1

            sproof.items.push(s);

5258

1

            set_author_noting_inherent_data(sproof);

5259

1

5260

1

            run_block();

5261

1

5262

1

            // After this it should not be assigned anymore, since credits are not payable

5263

1

            run_to_session(4u32);

5264

1

            // Nobody should be assigned to para 1001

5265

1

            let assignment = CollatorAssignment::collator_container_chain();

5266

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5267

1

});

5268

1

5269

5270

#[test]

5271

1

fn test_ed_plus_collator_assignment_credit_session_minus_1_purchase_fails() {

5272

1

    ExtBuilder::default()

5273

1

        .with_balances(vec![

5274

1

            // Alice gets 10k extra tokens for her mapping deposit

5275

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5276

1

            (AccountId::from(BOB), 100_000 * UNIT),

5277

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5278

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5279

1

])

5280

1

        .with_collators(vec![

5281

1

            (AccountId::from(ALICE), 210 * UNIT),

5282

1

            (AccountId::from(BOB), 100 * UNIT),

5283

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5284

1

            (AccountId::from(DAVE), 100 * UNIT),

5285

1

])

5286

1

        .build()

5287

1

        .execute_with(|| {

5288

1

            run_to_block(2);

5289

1

            // Assert current slot gets updated

5290

1

            assert_eq!(current_slot(), 1u64);

5291

1

            assert!(current_author() == AccountId::from(BOB));

5292

5293

            // Alice and Bob collate in our chain

5294

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5295

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5296

1

5297

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5298

5299

1

            assert_ok!(Registrar::register(

5300

1

                origin_of(ALICE.into()),

5301

1

                1001.into(),

5302

1

                empty_genesis_data(),

5303

1

                None

5304

1

));

5305

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5306

1

            assert_ok!(Registrar::mark_valid_for_collating(

5307

1

                root_origin(),

5308

1

                1001.into()

5309

1

));

5310

            // Need to reset credits to 0 because now parachains are given free credits on register

5311

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5312

1

                root_origin(),

5313

1

                1001.into(),

5314

1

5315

1

));

5316

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5317

1

                + crate::EXISTENTIAL_DEPOSIT

5318

1

                - 1;

5319

1

5320

1

            // Fill the tank

5321

1

            assert_ok!(ServicesPayment::purchase_credits(

5322

1

                origin_of(ALICE.into()),

5323

1

                1001.into(),

5324

1

                credits_1001

5325

1

));

5326

5327

            // Assignment should happen after 2 sessions

5328

1

            run_to_session(1u32);

5329

1

            let assignment = CollatorAssignment::collator_container_chain();

5330

1

            assert!(assignment.container_chains.is_empty());

5331

1

            run_to_session(2u32);

5332

1

            // Charlie and Dave should not be assigned to para 1001

5333

1

            let assignment = CollatorAssignment::collator_container_chain();

5334

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5335

1

});

5336

1

5337

5338

#[test]

5339

1

fn test_collator_assignment_credits_with_purchase_can_be_combined() {

5340

1

    ExtBuilder::default()

5341

1

        .with_balances(vec![

5342

1

            // Alice gets 10k extra tokens for her mapping deposit

5343

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5344

1

            (AccountId::from(BOB), 100_000 * UNIT),

5345

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5346

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5347

1

])

5348

1

        .with_collators(vec![

5349

1

            (AccountId::from(ALICE), 210 * UNIT),

5350

1

            (AccountId::from(BOB), 100 * UNIT),

5351

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5352

1

            (AccountId::from(DAVE), 100 * UNIT),

5353

1

])

5354

1

        .build()

5355

1

        .execute_with(|| {

5356

1

            run_to_block(2);

5357

1

            // Assert current slot gets updated

5358

1

            assert_eq!(current_slot(), 1u64);

5359

1

            assert!(current_author() == AccountId::from(BOB));

5360

5361

            // Alice and Bob collate in our chain

5362

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5363

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5364

1

5365

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5366

5367

1

            assert_ok!(Registrar::register(

5368

1

                origin_of(ALICE.into()),

5369

1

                1001.into(),

5370

1

                empty_genesis_data(),

5371

1

                None

5372

1

));

5373

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5374

1

            assert_ok!(Registrar::mark_valid_for_collating(

5375

1

                root_origin(),

5376

1

                1001.into()

5377

1

));

5378

5379

            // We assign one session to free credits

5380

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5381

1

                root_origin(),

5382

1

                1001.into(),

5383

1

5384

1

));

5385

            // We buy another session through the tank

5386

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5387

1

                + crate::EXISTENTIAL_DEPOSIT;

5388

1

5389

1

            // Fill the tank

5390

1

            assert_ok!(ServicesPayment::purchase_credits(

5391

1

                origin_of(ALICE.into()),

5392

1

                1001.into(),

5393

1

                credits_1001

5394

1

));

5395

5396

            // Assignment should happen after 2 sessions

5397

1

            run_to_session(1u32);

5398

1

            let assignment = CollatorAssignment::collator_container_chain();

5399

1

            assert!(assignment.container_chains.is_empty());

5400

1

            run_to_session(2u32);

5401

1

            // Charlie and Dave should be assigned to para 1001

5402

1

            let assignment = CollatorAssignment::collator_container_chain();

5403

1

            assert_eq!(

5404

1

                assignment.container_chains[&1001u32.into()],

5405

1

                vec![CHARLIE.into(), DAVE.into()]

5406

1

);

5407

1

});

5408

1

5409

5410

#[test]

5411

1

fn test_block_credits_and_collator_assignation_credits_through_tank() {

5412

1

    ExtBuilder::default()

5413

1

        .with_balances(vec![

5414

1

            // Alice gets 10k extra tokens for her mapping deposit

5415

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5416

1

            (AccountId::from(BOB), 100_000 * UNIT),

5417

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5418

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5419

1

])

5420

1

        .with_collators(vec![

5421

1

            (AccountId::from(ALICE), 210 * UNIT),

5422

1

            (AccountId::from(BOB), 100 * UNIT),

5423

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5424

1

            (AccountId::from(DAVE), 100 * UNIT),

5425

1

])

5426

1

        .build()

5427

1

        .execute_with(|| {

5428

1

            run_to_block(2);

5429

1

            // Assert current slot gets updated

5430

1

            assert_eq!(current_slot(), 1u64);

5431

1

            assert!(current_author() == AccountId::from(BOB));

5432

5433

            // Alice and Bob collate in our chain

5434

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5435

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5436

1

5437

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5438

5439

1

            assert_ok!(Registrar::register(

5440

1

                origin_of(ALICE.into()),

5441

1

                1001.into(),

5442

1

                empty_genesis_data(),

5443

1

                None

5444

1

));

5445

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5446

1

            assert_ok!(Registrar::mark_valid_for_collating(

5447

1

                root_origin(),

5448

1

                1001.into()

5449

1

));

5450

5451

            // We make all free credits 0

5452

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5453

1

                root_origin(),

5454

1

                1001.into(),

5455

1

5456

1

));

5457

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5458

1

                root_origin(),

5459

1

                1001.into(),

5460

1

5461

1

));

5462

5463

            // We buy 2 sessions through tank

5464

1

            let collator_assignation_credits =

5465

1

                collator_assignment_credits_to_required_balance(2, 1001.into());

5466

1

            let block_production_credits =

5467

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into());

5468

1

5469

1

            // Fill the tank

5470

1

            assert_ok!(ServicesPayment::purchase_credits(

5471

1

                origin_of(ALICE.into()),

5472

1

                1001.into(),

5473

1

                collator_assignation_credits

5474

1

                    + block_production_credits

5475

1

                    + crate::EXISTENTIAL_DEPOSIT

5476

1

));

5477

5478

            // Assignment should happen after 2 sessions

5479

1

            run_to_session(1u32);

5480

1

            let assignment = CollatorAssignment::collator_container_chain();

5481

1

            assert!(assignment.container_chains.is_empty());

5482

1

            run_to_session(2u32);

5483

1

            // Charlie and Dave should be assigned to para 1001

5484

1

            let assignment = CollatorAssignment::collator_container_chain();

5485

1

            assert_eq!(

5486

1

                assignment.container_chains[&1001u32.into()],

5487

1

                vec![CHARLIE.into(), DAVE.into()]

5488

1

);

5489

5490

            // After this it should not be assigned anymore, since credits are not payable

5491

1

            run_to_session(4u32);

5492

1

            // Nobody should be assigned to para 1001

5493

1

            let assignment = CollatorAssignment::collator_container_chain();

5494

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5495

1

});

5496

1

5497

5498

#[test]

5499

1

fn test_migration_services_collator_assignment_payment() {

5500

1

    ExtBuilder::default().build().execute_with(|| {

5501

1

        // Register a new parachain with no credits

5502

1

        assert_ok!(Registrar::register(

5503

1

            origin_of(ALICE.into()),

5504

1

            1001.into(),

5505

1

            empty_genesis_data(),

5506

1

            None

5507

1

));

5508

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5509

1

        assert_ok!(Registrar::mark_valid_for_collating(

5510

1

            root_origin(),

5511

1

            1001.into()

5512

1

));

5513

        // Register another parachain with no credits, do not mark this as valid for collation

5514

1

        assert_ok!(Registrar::register(

5515

1

            origin_of(ALICE.into()),

5516

1

            1002.into(),

5517

1

            empty_genesis_data(),

5518

1

            None

5519

1

));

5520

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1002.into());

5521

1

        assert_ok!(Registrar::mark_valid_for_collating(

5522

1

            root_origin(),

5523

1

            1002.into()

5524

1

));

5525

5526

        // Need to reset credits to 0 because now parachains are given free credits on register

5527

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

5528

1

            root_origin(),

5529

1

            1001.into(),

5530

1

5531

1

));

5532

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

5533

1

            root_origin(),

5534

1

            1002.into(),

5535

1

5536

1

));

5537

5538

1

        let credits_1001 =

5539

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

5540

1

                .unwrap_or_default();

5541

1

        assert_eq!(credits_1001, 0);

5542

1

        let credits_1002 =

5543

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

5544

1

                .unwrap_or_default();

5545

1

        assert_eq!(credits_1002, 0);

5546

5547

        // Apply migration

5548

1

        let migration =

5549

1

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

5550

1

        migration.migrate(Default::default());

5551

1

5552

1

        // Both parachains have been given credits

5553

1

        let credits_1001 =

5554

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

5555

1

                .unwrap_or_default();

5556

1

        assert_eq!(credits_1001, crate::FreeCollatorAssignmentCredits::get());

5557

1

        let credits_1002 =

5558

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

5559

1

                .unwrap_or_default();

5560

1

        assert_eq!(credits_1002, crate::FreeCollatorAssignmentCredits::get());

5561

1

});

5562

1

5563

5564

#[test]

5565

1

fn test_migration_foreign_asset_creator() {

5566

1

    ExtBuilder::default().build().execute_with(|| {

5567

1

        // Sample pairs of asset id with v3 location

5568

1

        let (asset_id1, location_1) = (

5569

1

            <Runtime as pallet_assets::Config<ForeignAssetsInstance>>::AssetId::from(13u16),

5570

1

            V3MultiLocation::new(

5571

1

1,

5572

1

                V3Junctions::X2(

5573

1

                    V3Junction::PalletInstance(1),

5574

1

                    V3Junction::AccountIndex64 {

5575

1

                        network: Some(V3NetworkId::BitcoinCore),

5576

1

                        index: 5,

5577

1

},

5578

1

),

5579

1

),

5580

1

);

5581

1

5582

1

        let (asset_id2, location_2) = (

5583

1

            <Runtime as pallet_assets::Config<ForeignAssetsInstance>>::AssetId::from(14u16),

5584

1

            V3MultiLocation::new(

5585

1

1,

5586

1

                V3Junctions::X2(

5587

1

                    V3Junction::PalletInstance(2),

5588

1

                    V3Junction::AccountIndex64 {

5589

1

                        network: Some(V3NetworkId::Kusama),

5590

1

                        index: 10,

5591

1

},

5592

1

),

5593

1

),

5594

1

);

5595

1

5596

1

        put_storage_value(

5597

1

            AssetIdToForeignAsset::<Runtime>::pallet_prefix(),

5598

1

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

5599

1

            &asset_id1.blake2_128_concat(),

5600

1

            location_1,

5601

1

);

5602

1

        put_storage_value(

5603

1

            AssetIdToForeignAsset::<Runtime>::pallet_prefix(),

5604

1

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

5605

1

            &asset_id2.blake2_128_concat(),

5606

1

            location_2,

5607

1

);

5608

1

5609

1

        put_storage_value(

5610

1

            ForeignAssetToAssetId::<Runtime>::pallet_prefix(),

5611

1

            ForeignAssetToAssetId::<Runtime>::storage_prefix(),

5612

1

            &location_1.blake2_128_concat(),

5613

1

            asset_id1,

5614

1

);

5615

1

        put_storage_value(

5616

1

            ForeignAssetToAssetId::<Runtime>::pallet_prefix(),

5617

1

            ForeignAssetToAssetId::<Runtime>::storage_prefix(),

5618

1

            &location_2.blake2_128_concat(),

5619

1

            asset_id2,

5620

1

);

5621

1

5622

1

        // Let's run the migration now

5623

1

        let foreign_asset_creator_migration: ForeignAssetCreatorMigration<Runtime> =

5624

1

            ForeignAssetCreatorMigration(PhantomData);

5625

1

        let weight_consumed = foreign_asset_creator_migration.migrate(Default::default());

5626

1

        assert_eq!(

5627

1

            weight_consumed,

5628

1

            <Runtime as frame_system::Config>::DbWeight::get().reads_writes(1 * 4, 2 * 4)

5629

1

);

5630

5631

        // Let's check if everything is migrated properly

5632

1

        assert_eq!(

5633

1

            AssetIdToForeignAsset::<Runtime>::get(asset_id1),

5634

1

            Some(Location::try_from(location_1).unwrap())

5635

1

);

5636

1

        assert_eq!(

5637

1

            AssetIdToForeignAsset::<Runtime>::get(asset_id2),

5638

1

            Some(Location::try_from(location_2).unwrap())

5639

1

);

5640

5641

1

        assert_eq!(

5642

1

            ForeignAssetToAssetId::<Runtime>::get(Location::try_from(location_1).unwrap()),

5643

1

            Some(asset_id1)

5644

1

);

5645

1

        assert_eq!(

5646

1

            ForeignAssetToAssetId::<Runtime>::get(Location::try_from(location_2).unwrap()),

5647

1

            Some(asset_id2)

5648

1

);

5649

1

});

5650

1

5651

5652

#[test]

5653

1

fn test_max_collators_uses_pending_value() {

5654

1

    // Start with max_collators = 100, and collators_per_container = 2

5655

1

    // Set max_collators = 2, and collators_per_container = 3

5656

1

    // It should be impossible to have more than 2 collators per container at any point in time

5657

1

    ExtBuilder::default()

5658

1

        .with_balances(vec![

5659

1

            // Alice gets 10k extra tokens for her mapping deposit

5660

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5661

1

            (AccountId::from(BOB), 100_000 * UNIT),

5662

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5663

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5664

1

])

5665

1

        .with_collators(vec![

5666

1

            (AccountId::from(ALICE), 210 * UNIT),

5667

1

            (AccountId::from(BOB), 100 * UNIT),

5668

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5669

1

            (AccountId::from(DAVE), 100 * UNIT),

5670

1

])

5671

1

        .with_empty_parachains(vec![1001])

5672

1

        .with_config(pallet_configuration::HostConfiguration {

5673

1

            max_collators: 100,

5674

1

            min_orchestrator_collators: 1,

5675

1

            max_orchestrator_collators: 1,

5676

1

            collators_per_container: 2,

5677

1

            full_rotation_period: 24,

5678

1

            ..Default::default()

5679

1

})

5680

1

        .build()

5681

1

        .execute_with(|| {

5682

1

            run_to_block(2);

5683

1

5684

1

            // Initial assignment: 1 collator in orchestrator chain and 2 collators in container 1001

5685

1

            let assignment = CollatorAssignment::collator_container_chain();

5686

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 2);

5687

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5688

5689

1

            assert_ok!(Configuration::set_max_collators(root_origin(), 2));

5690

1

            assert_ok!(Configuration::set_collators_per_container(root_origin(), 3));

5691

5692

            // Check invariant for all intermediate assignments. We set collators_per_container = 3

5693

            // but we also set max_collators = 2, so no collators will be assigned to container

5694

            // chains after the change is applied.

5695

5

            for session in 1..=4 {

5696

4

                run_to_session(session);

5697

4

5698

4

                let assignment = CollatorAssignment::collator_container_chain();

5699

4

                assert!(

5700

4

                    assignment.container_chains[&1001u32.into()].len() <= 2,

5701

                    "session {}: {} collators assigned to container chain 1001",

5702

                    session,

5703

                    assignment.container_chains[&1001u32.into()].len()

5704

);

5705

5706

5707

            // Final assignment: because max_collators = 2, there are only 2 collators, one in

5708

            // orchestrator chain, and the other one idle

5709

1

            let assignment = CollatorAssignment::collator_container_chain();

5710

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 0);

5711

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5712

1

});

5713

1

5714

5715

#[test]

5716

1

fn test_slow_adjusting_multiplier_changes_in_response_to_consumed_weight() {

5717

1

    ExtBuilder::default()

5718

1

        .with_collators(vec![

5719

1

            (AccountId::from(ALICE), 210 * UNIT),

5720

1

            (AccountId::from(BOB), 100 * UNIT),

5721

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5722

1

            (AccountId::from(DAVE), 100 * UNIT),

5723

1

])

5724

1

        .build()

5725

1

        .execute_with(|| {

5726

1

            end_block();

5727

1

            // If the block is full, the multiplier increases

5728

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5729

1

            start_block();

5730

1

            let max_block_weights = crate::RuntimeBlockWeights::get();

5731

1

            frame_support::storage::unhashed::put(

5732

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5733

3

                &ConsumedWeight::new(|class| {

5734

3

                    max_block_weights

5735

3

                        .get(class)

5736

3

                        .max_total

5737

3

                        .unwrap_or(Weight::MAX)

5738

3

}),

5739

1

);

5740

1

            end_block();

5741

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5742

1

            assert!(current_multiplier > before_multiplier);

5743

5744

            // If the block is empty, the multiplier decreases

5745

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5746

1

            start_block();

5747

1

            frame_support::storage::unhashed::put(

5748

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5749

3

                &ConsumedWeight::new(|_class| Weight::zero()),

5750

1

);

5751

1

            end_block();

5752

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5753

1

            assert!(current_multiplier < before_multiplier);

5754

1

});

5755

1

5756

5757

#[test]

5758

1

fn test_collator_assignment_tip_priority_on_congestion() {

5759

1

    ExtBuilder::default()

5760

1

        .with_balances(vec![

5761

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5762

1

            (AccountId::from(BOB), 100_000 * UNIT),

5763

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5764

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5765

1

])

5766

1

        .with_collators(vec![

5767

1

            (AccountId::from(ALICE), 210 * UNIT),

5768

1

            (AccountId::from(BOB), 100 * UNIT),

5769

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5770

1

            (AccountId::from(DAVE), 100 * UNIT),

5771

1

])

5772

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5773

1

        .build()

5774

1

        .execute_with(|| {

5775

1

            let para_id = 1003u32;

5776

1

            let tank_funds = 100 * UNIT;

5777

1

            let max_tip = 1 * UNIT;

5778

1

5779

1

            assert_eq!(

5780

1

                CollatorAssignment::collator_container_chain().container_chains[&1003u32.into()]

5781

1

                    .len(),

5782

1

5783

1

);

5784

5785

            // Send funds to tank

5786

1

            assert_ok!(ServicesPayment::purchase_credits(

5787

1

                origin_of(ALICE.into()),

5788

1

                para_id.into(),

5789

1

                tank_funds,

5790

1

));

5791

5792

            // Set tip for 1003

5793

1

            assert_ok!(ServicesPayment::set_max_tip(

5794

1

                root_origin(),

5795

1

                para_id.into(),

5796

1

                Some(max_tip),

5797

1

));

5798

5799

1

            run_to_session(2);

5800

1

            assert_eq!(

5801

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5802

1

                    .len(),

5803

1

2,

5804

1

);

5805

1

});

5806

1

5807

5808

#[test]

5809

1

fn test_collator_assignment_tip_charged_on_congestion() {

5810

1

    ExtBuilder::default()

5811

1

        .with_balances(vec![

5812

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5813

1

            (AccountId::from(BOB), 100_000 * UNIT),

5814

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5815

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5816

1

])

5817

1

        .with_collators(vec![

5818

1

            (AccountId::from(ALICE), 210 * UNIT),

5819

1

            (AccountId::from(BOB), 100 * UNIT),

5820

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5821

1

            (AccountId::from(DAVE), 100 * UNIT),

5822

1

])

5823

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5824

1

        .build()

5825

1

        .execute_with(|| {

5826

1

            let tank_funds = 100 * UNIT;

5827

1

            let max_tip = 1 * UNIT;

5828

1

            let para_id = 1003u32;

5829

1

5830

1

            // Send funds to tank

5831

1

            assert_ok!(ServicesPayment::purchase_credits(

5832

1

                origin_of(ALICE.into()),

5833

1

                para_id.into(),

5834

1

                tank_funds,

5835

1

));

5836

5837

            // Set tip for para_id

5838

1

            assert_ok!(ServicesPayment::set_max_tip(

5839

1

                root_origin(),

5840

1

                para_id.into(),

5841

1

                Some(max_tip),

5842

1

));

5843

5844

1

            run_to_session(1);

5845

1

            assert_eq!(

5846

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id.into())),

5847

1

                tank_funds - max_tip,

5848

1

);

5849

1

});

5850

1

5851

5852

#[test]

5853

1

fn test_collator_assignment_tip_not_assigned_on_insufficient_balance() {

5854

1

    ExtBuilder::default()

5855

1

        .with_balances(vec![

5856

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5857

1

            (AccountId::from(BOB), 100_000 * UNIT),

5858

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5859

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5860

1

])

5861

1

        .with_collators(vec![

5862

1

            (AccountId::from(ALICE), 210 * UNIT),

5863

1

            (AccountId::from(BOB), 100 * UNIT),

5864

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5865

1

            (AccountId::from(DAVE), 100 * UNIT),

5866

1

])

5867

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5868

1

        .build()

5869

1

        .execute_with(|| {

5870

1

            let tank_funds = 1 * UNIT;

5871

1

            let max_tip = 1 * UNIT;

5872

1

            let para_id = 1003u32;

5873

1

5874

1

            // Send insufficient funds to tank for tip for 2 sessions

5875

1

            assert_ok!(ServicesPayment::purchase_credits(

5876

1

                origin_of(ALICE.into()),

5877

1

                para_id.into(),

5878

1

                tank_funds,

5879

1

));

5880

5881

            // Set tip for para_id

5882

1

            assert_ok!(ServicesPayment::set_max_tip(

5883

1

                root_origin(),

5884

1

                para_id.into(),

5885

1

                Some(max_tip),

5886

1

));

5887

5888

1

            run_to_session(1);

5889

1

            assert_eq!(

5890

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5891

1

                    .len(),

5892

1

5893

1

);

5894

1

});

5895

1

5896

5897

#[test]

5898

1

fn test_collator_assignment_tip_only_charge_willing_paras() {

5899

1

    ExtBuilder::default()

5900

1

        .with_balances(vec![

5901

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5902

1

            (AccountId::from(BOB), 100_000 * UNIT),

5903

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5904

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5905

1

            (AccountId::from(EVE), 100_000 * UNIT),

5906

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5907

1

])

5908

1

        .with_collators(vec![

5909

1

            (AccountId::from(ALICE), 210 * UNIT),

5910

1

            (AccountId::from(BOB), 100 * UNIT),

5911

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5912

1

            (AccountId::from(DAVE), 100 * UNIT),

5913

1

            (AccountId::from(EVE), 100 * UNIT),

5914

1

            (AccountId::from(FERDIE), 100 * UNIT),

5915

1

])

5916

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5917

1

        .build()

5918

1

        .execute_with(|| {

5919

1

            let tank_funds = 100 * UNIT;

5920

1

            let max_tip = 1 * UNIT;

5921

1

            let para_id_with_tip = 1003u32;

5922

1

            let para_id_without_tip = 1001u32;

5923

1

5924

1

            // Send funds to tank to both paras

5925

1

            assert_ok!(ServicesPayment::purchase_credits(

5926

1

                origin_of(ALICE.into()),

5927

1

                para_id_with_tip.into(),

5928

1

                tank_funds,

5929

1

));

5930

1

            assert_ok!(ServicesPayment::purchase_credits(

5931

1

                origin_of(ALICE.into()),

5932

1

                para_id_without_tip.into(),

5933

1

                tank_funds,

5934

1

));

5935

5936

            // Only set tip for 1003

5937

1

            assert_ok!(ServicesPayment::set_max_tip(

5938

1

                root_origin(),

5939

1

                para_id_with_tip.into(),

5940

1

                Some(max_tip),

5941

1

));

5942

5943

1

            run_to_session(2);

5944

1

5945

1

            let assignment = CollatorAssignment::collator_container_chain().container_chains;

5946

1

5947

1

            // 2 out of the 3 paras should have collators assigned, with one paying tip to get

5948

1

            // prioritized, and the other selected at random that should not be charged any tips

5949

1

            assert_eq!(assignment[&para_id_with_tip.into()].len(), 2);

5950

1

            assert_eq!(

5951

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_with_tip.into())),

5952

1

                tank_funds - max_tip * 2,

5953

1

);

5954

5955

1

            assert_eq!(assignment[&para_id_without_tip.into()].len(), 2);

5956

1

            assert_eq!(

5957

1

                Balances::usable_balance(ServicesPayment::parachain_tank(

5958

1

                    para_id_without_tip.into()

5959

1

)),

5960

1

                tank_funds,

5961

1

);

5962

1

});

5963

1

5964

5965

#[test]

5966

1

fn test_collator_assignment_tip_withdraw_min_tip() {

5967

1

    ExtBuilder::default()

5968

1

        .with_balances(vec![

5969

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5970

1

            (AccountId::from(BOB), 100_000 * UNIT),

5971

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5972

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5973

1

            (AccountId::from(EVE), 100_000 * UNIT),

5974

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5975

1

])

5976

1

        .with_collators(vec![

5977

1

            (AccountId::from(ALICE), 210 * UNIT),

5978

1

            (AccountId::from(BOB), 100 * UNIT),

5979

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5980

1

            (AccountId::from(DAVE), 100 * UNIT),

5981

1

            (AccountId::from(EVE), 100 * UNIT),

5982

1

            (AccountId::from(FERDIE), 100 * UNIT),

5983

1

])

5984

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5985

1

        .build()

5986

1

        .execute_with(|| {

5987

1

            let tank_funds = 100 * UNIT;

5988

1

            let max_tip_1003 = 3 * UNIT;

5989

1

            let max_tip_1002 = 2 * UNIT;

5990

1

            let para_id_1003 = 1003u32;

5991

1

            let para_id_1002 = 1002u32;

5992

1

5993

1

            // Send funds to tank to both paras

5994

1

            assert_ok!(ServicesPayment::purchase_credits(

5995

1

                origin_of(ALICE.into()),

5996

1

                para_id_1003.into(),

5997

1

                tank_funds,

5998

1

));

5999

1

            assert_ok!(ServicesPayment::purchase_credits(

6000

1

                origin_of(ALICE.into()),

6001

1

                para_id_1002.into(),

6002

1

                tank_funds,

6003

1

));

6004

6005

            // Set tips

6006

1

            assert_ok!(ServicesPayment::set_max_tip(

6007

1

                root_origin(),

6008

1

                para_id_1003.into(),

6009

1

                Some(max_tip_1003),

6010

1

));

6011

1

            assert_ok!(ServicesPayment::set_max_tip(

6012

1

                root_origin(),

6013

1

                para_id_1002.into(),

6014

1

                Some(max_tip_1002),

6015

1

));

6016

6017

1

            run_to_session(2);

6018

1

6019

1

            assert_eq!(

6020

1

                CollatorAssignment::collator_container_chain().container_chains

6021

1

                    [&para_id_1003.into()]

6022

1

                    .len(),

6023

1

6024

1

);

6025

1

            assert_eq!(

6026

1

                CollatorAssignment::collator_container_chain().container_chains

6027

1

                    [&para_id_1002.into()]

6028

1

                    .len(),

6029

1

6030

1

);

6031

6032

            // Should have withdrawn the lowest tip from both paras

6033

1

            assert_eq!(

6034

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1003.into())),

6035

1

                tank_funds - max_tip_1002 * 2,

6036

1

);

6037

6038

1

            assert_eq!(

6039

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1002.into())),

6040

1

                tank_funds - max_tip_1002 * 2,

6041

1

);

6042

1

});

6043

1

6044

6045

#[test]

6046

1

fn test_migration_data_preservers_assignments() {

6047

1

    ExtBuilder::default().build().execute_with(|| {

6048

        use {

6049

            crate::{MaxAssignmentsPerParaId, MaxNodeUrlLen},

6050

            frame_support::{

6051

                migration::{have_storage_value, put_storage_value},

6052

                Blake2_128Concat, StorageHasher,

6053

},

6054

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

6055

            sp_runtime::BoundedBTreeSet,

6056

            sp_std::collections::btree_set::BTreeSet,

6057

            tanssi_runtime_common::migrations::DataPreserversAssignmentsMigration,

6058

};

6059

6060

        macro_rules! bset {

6061

            ( $($value:expr),* $(,)? ) => {

6062

6063

                    let mut set = BoundedBTreeSet::new();

6064

$(

6065

                        set.try_insert($value).expect("max bound reached");

6066

)*

6067

set

6068

6069

6070

6071

6072

        macro_rules! set {

6073

            ( $($value:expr),* $(,)? ) => {

6074

6075

                    let mut set = BTreeSet::new();

6076

$(

6077

                        set.insert($value);

6078

)*

6079

set

6080

6081

6082

6083

6084

1

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

6085

1

        let free_request = crate::PreserversAssignementPaymentRequest::Free;

6086

1

        let free_witness = crate::PreserversAssignementPaymentWitness::Free;

6087

1

6088

1

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

6089

1

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

6090

1

6091

1

        // Register 2 parachains

6092

1

        assert_ok!(Registrar::register(

6093

1

            origin_of(ALICE.into()),

6094

1

            1001.into(),

6095

1

            empty_genesis_data(),

6096

1

            None

6097

1

));

6098

1

        assert_ok!(Registrar::register(

6099

1

            origin_of(BOB.into()),

6100

1

            1002.into(),

6101

1

            empty_genesis_data(),

6102

1

            None

6103

1

));

6104

6105

        // Set bootnodes in old storage

6106

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

6107

1

            b"alpha".to_vec().try_into().unwrap(),

6108

1

            b"beta".to_vec().try_into().unwrap(),

6109

1

6110

1

        .try_into()

6111

1

        .unwrap();

6112

1

        put_storage_value(

6113

1

            pallet_prefix,

6114

1

            storage_item_prefix,

6115

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode()),

6116

1

            bootnodes,

6117

1

);

6118

1

6119

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

6120

1

            b"delta".to_vec().try_into().unwrap(),

6121

1

            b"gamma".to_vec().try_into().unwrap(),

6122

1

6123

1

        .try_into()

6124

1

        .unwrap();

6125

1

        put_storage_value(

6126

1

            pallet_prefix,

6127

1

            storage_item_prefix,

6128

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode()),

6129

1

            bootnodes,

6130

1

);

6131

1

6132

1

        // Apply migration

6133

1

        let migration = DataPreserversAssignmentsMigration::<Runtime>(Default::default());

6134

1

        migration.migrate(Default::default());

6135

1

6136

1

        // Check old storage is empty

6137

1

        assert!(!have_storage_value(

6138

1

            pallet_prefix,

6139

1

            storage_item_prefix,

6140

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode())

6141

1

));

6142

1

        assert!(!have_storage_value(

6143

1

            pallet_prefix,

6144

1

            storage_item_prefix,

6145

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode())

6146

1

));

6147

6148

        // Check new storage

6149

1

        assert_eq!(

6150

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1001)).into_inner(),

6151

1

            set![0, 1]

6152

1

);

6153

1

        assert_eq!(

6154

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1002)).into_inner(),

6155

1

            set![2, 3]

6156

1

);

6157

1

        assert_eq!(pallet_data_preservers::NextProfileId::<Runtime>::get(), 4);

6158

1

        assert_eq!(

6159

1

            pallet_data_preservers::Profiles::<Runtime>::get(0),

6160

1

            Some(RegisteredProfile {

6161

1

                account: account.clone(),

6162

1

                deposit: 0,

6163

1

                assignment: Some((1001.into(), free_witness)),

6164

1

                profile: Profile {

6165

1

                    url: b"alpha".to_vec().try_into().unwrap(),

6166

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

6167

1

                    mode: ProfileMode::Bootnode,

6168

1

                    assignment_request: free_request,

6169

1

6170

1

})

6171

1

);

6172

1

        assert_eq!(

6173

1

            pallet_data_preservers::Profiles::<Runtime>::get(1),

6174

1

            Some(RegisteredProfile {

6175

1

                account: account.clone(),

6176

1

                deposit: 0,

6177

1

                assignment: Some((1001.into(), free_witness)),

6178

1

                profile: Profile {

6179

1

                    url: b"beta".to_vec().try_into().unwrap(),

6180

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

6181

1

                    mode: ProfileMode::Bootnode,

6182

1

                    assignment_request: free_request,

6183

1

6184

1

})

6185

1

);

6186

1

        assert_eq!(

6187

1

            pallet_data_preservers::Profiles::<Runtime>::get(2),

6188

1

            Some(RegisteredProfile {

6189

1

                account: account.clone(),

6190

1

                deposit: 0,

6191

1

                assignment: Some((1002.into(), free_witness)),

6192

1

                profile: Profile {

6193

1

                    url: b"delta".to_vec().try_into().unwrap(),

6194

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

6195

1

                    mode: ProfileMode::Bootnode,

6196

1

                    assignment_request: free_request,

6197

1

6198

1

})

6199

1

);

6200

1

        assert_eq!(

6201

1

            pallet_data_preservers::Profiles::<Runtime>::get(3),

6202

1

            Some(RegisteredProfile {

6203

1

                account: account.clone(),

6204

1

                deposit: 0,

6205

1

                assignment: Some((1002.into(), free_witness)),

6206

1

                profile: Profile {

6207

1

                    url: b"gamma".to_vec().try_into().unwrap(),

6208

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

6209

1

                    mode: ProfileMode::Bootnode,

6210

1

                    assignment_request: free_request,

6211

1

6212

1

})

6213

1

);

6214

1

})

6215

1

6216

6217

#[test]

6218

1

fn test_migration_registrar_reserves_to_hold() {

6219

1

    ExtBuilder::default()

6220

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

6221

1

        .build()

6222

1

        .execute_with(|| {

6223

            use {

6224

                frame_support::traits::{fungible::InspectHold, ReservableCurrency},

6225

                pallet_registrar::DepositInfo,

6226

                tanssi_runtime_common::migrations::RegistrarReserveToHoldMigration,

6227

};

6228

6229

1

            let deposit: Balance = 100 * UNIT;

6230

1

            let account: AccountId = DAVE.into();

6231

1

6232

1

            assert_ok!(Balances::reserve(&account, deposit));

6233

6234

1

            pallet_registrar::RegistrarDeposit::<Runtime>::insert(

6235

1

                ParaId::from(1001),

6236

1

                DepositInfo {

6237

1

                    creator: account.clone(),

6238

1

                    deposit,

6239

1

},

6240

1

);

6241

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

6242

            // Apply migration

6243

1

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

6244

1

            migration.migrate(Default::default());

6245

1

6246

1

            // Holds also count as reserved balance, so the total reserved amount

6247

1

            // shouldn't change after the migration

6248

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

6249

6250

1

            assert_eq!(

6251

1

                Balances::balance_on_hold(

6252

1

                    &pallet_registrar::HoldReason::RegistrarDeposit.into(),

6253

1

                    &account

6254

1

),

6255

1

                deposit

6256

1

);

6257

1

})

6258

1

6259

6260

#[test]

6261

1

fn test_container_deregister_unassign_data_preserver() {

6262

1

    ExtBuilder::default()

6263

1

        .with_balances(vec![

6264

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6265

1

            (AccountId::from(BOB), 100_000 * UNIT),

6266

1

])

6267

1

        .build()

6268

1

        .execute_with(|| {

6269

            use pallet_data_preservers::{

6270

                AssignerParameterOf, ParaIdsFilter, Profile, ProfileMode, ProviderRequestOf,

6271

};

6272

6273

1

            let profile = Profile {

6274

1

                url: b"test".to_vec().try_into().unwrap(),

6275

1

                para_ids: ParaIdsFilter::AnyParaId,

6276

1

                mode: ProfileMode::Bootnode,

6277

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

6278

1

};

6279

1

6280

1

            let para_id = ParaId::from(1002);

6281

1

            let profile_id = 0u64;

6282

1

6283

1

            assert_ok!(Registrar::register(

6284

1

                origin_of(ALICE.into()),

6285

1

                para_id,

6286

1

                empty_genesis_data(),

6287

1

                None

6288

1

));

6289

6290

1

            assert_ok!(DataPreservers::create_profile(

6291

1

                origin_of(BOB.into()),

6292

1

                profile.clone(),

6293

1

));

6294

6295

            // Start assignment

6296

1

            assert_ok!(DataPreservers::start_assignment(

6297

1

                origin_of(ALICE.into()),

6298

1

                profile_id,

6299

1

                para_id,

6300

1

                AssignerParameterOf::<Runtime>::Free

6301

1

));

6302

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&0u64));

6303

6304

            // Deregister from Registrar

6305

1

            assert_ok!(Registrar::deregister(root_origin(), para_id), ());

6306

6307

            // Check DataPreserver assignment has been cleared

6308

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).is_empty());

6309

1

});

6310

1