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::*, RewardsCollatorCommission, StreamPayment, StreamPaymentAssetId, TimeUnit,

22

        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::{assert_noop, assert_ok, BoundedVec},

28

    frame_system::ConsumedWeight,

29

    nimbus_primitives::NIMBUS_KEY_ID,

30

    pallet_author_noting_runtime_api::runtime_decl_for_author_noting_api::AuthorNotingApi,

31

    pallet_balances::Instance1,

32

    pallet_collator_assignment_runtime_api::runtime_decl_for_collator_assignment_api::CollatorAssignmentApi,

33

    pallet_migrations::Migration,

34

    pallet_pooled_staking::{

35

        traits::IsCandidateEligible, AllTargetPool, EligibleCandidate, PendingOperationKey,

36

        PendingOperationQuery, PoolsKey, SharesOrStake, TargetPool,

37

},

38

    pallet_registrar_runtime_api::{

39

        runtime_decl_for_registrar_api::RegistrarApi, ContainerChainGenesisData,

40

},

41

    parity_scale_codec::Encode,

42

    rococo_runtime_constants::fee::Perbill,

43

    sp_consensus_aura::AURA_ENGINE_ID,

44

    sp_core::Get,

45

    sp_runtime::{

46

        traits::{BadOrigin, BlakeTwo256, OpaqueKeys},

47

        DigestItem, FixedU128,

48

},

49

    sp_std::vec,

50

    tanssi_runtime_common::migrations::{

51

        HostConfigurationV3, MigrateConfigurationAddFullRotationMode,

52

        MigrateServicesPaymentAddCollatorAssignmentCredits, RegistrarPendingVerificationValueToMap,

53

},

54

    test_relay_sproof_builder::{HeaderAs, ParaHeaderSproofBuilder, ParaHeaderSproofBuilderItem},

55

    tp_traits::{ContainerChainBlockInfo, SlotFrequency},

56

    xcm::latest::prelude::*,

57

};

58

59

#[test]

60

1

fn genesis_balances() {

61

1

    ExtBuilder::default()

62

1

        .with_balances(vec![

63

1

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

64

1

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

65

1

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

66

1

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

67

1

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

68

1

])

69

1

        .with_collators(vec![

70

1

            // Remove ALICE and BOB from collators

71

1

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

72

1

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

73

1

])

74

1

        .build()

75

1

        .execute_with(|| {

76

1

            assert_eq!(

77

1

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

78

1

                210_000 * UNIT,

79

1

);

80

1

            assert_eq!(

81

1

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

82

1

                100_000 * UNIT,

83

1

);

84

1

});

85

1

86

87

#[test]

88

1

fn genesis_para_registrar() {

89

1

    ExtBuilder::default()

90

1

        .with_empty_parachains(vec![1001, 1002])

91

1

        .build()

92

1

        .execute_with(|| {

93

1

            assert_eq!(

94

1

                Registrar::registered_para_ids(),

95

1

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

96

1

);

97

1

});

98

1

99

100

#[test]

101

1

fn genesis_para_registrar_deregister() {

102

1

    ExtBuilder::default()

103

1

        .with_empty_parachains(vec![1001, 1002])

104

1

        .build()

105

1

        .execute_with(|| {

106

1

            assert_eq!(

107

1

                Registrar::registered_para_ids(),

108

1

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

109

1

);

110

111

1

            run_to_block(2);

112

1

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

113

114

            // Pending

115

1

            assert_eq!(

116

1

                Registrar::pending_registered_para_ids(),

117

1

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

118

1

);

119

120

1

            run_to_session(1);

121

1

            assert_eq!(

122

1

                Registrar::pending_registered_para_ids(),

123

1

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

124

1

);

125

1

            assert_eq!(

126

1

                Registrar::registered_para_ids(),

127

1

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

128

1

);

129

130

1

            run_to_session(2);

131

1

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

132

1

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

133

1

});

134

1

135

136

#[test]

137

1

fn genesis_para_registrar_runtime_api() {

138

1

    ExtBuilder::default()

139

1

        .with_empty_parachains(vec![1001, 1002])

140

1

        .build()

141

1

        .execute_with(|| {

142

1

            assert_eq!(

143

1

                Registrar::registered_para_ids(),

144

1

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

145

1

);

146

1

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

147

148

1

            run_to_block(2);

149

1

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

150

1

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

151

152

1

            run_to_session(1);

153

1

            assert_eq!(

154

1

                Registrar::registered_para_ids(),

155

1

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

156

1

);

157

1

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

158

159

1

            run_to_session(2);

160

1

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

161

1

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

162

1

});

163

1

164

165

#[test]

166

1

fn genesis_para_registrar_container_chain_genesis_data_runtime_api() {

167

1

    let genesis_data_1001 = empty_genesis_data();

168

1

    let genesis_data_1002 = ContainerChainGenesisData {

169

1

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

170

1

        name: Default::default(),

171

1

        id: Default::default(),

172

1

        fork_id: Default::default(),

173

1

        extensions: vec![],

174

1

        properties: Default::default(),

175

1

};

176

1

    ExtBuilder::default()

177

1

        .with_para_ids(vec![

178

1

            ParaRegistrationParams {

179

1

                para_id: 1001,

180

1

                genesis_data: genesis_data_1001.clone(),

181

1

                block_production_credits: u32::MAX,

182

1

                collator_assignment_credits: u32::MAX,

183

1

                parathread_params: None,

184

1

            },ParaRegistrationParams {

185

1

                para_id: 1002,

186

1

                genesis_data: genesis_data_1002.clone(),

187

1

                block_production_credits: u32::MAX,

188

1

                collator_assignment_credits: u32::MAX,

189

1

                parathread_params: None,

190

1

},

191

1

])

192

1

        .build()

193

1

        .execute_with(|| {

194

1

            assert_eq!(

195

1

                Registrar::registered_para_ids(),

196

1

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

197

1

);

198

1

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

199

200

1

            assert_eq!(

201

1

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

202

1

                Some(&genesis_data_1001)

203

1

);

204

1

            assert_eq!(

205

1

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

206

1

                Some(&genesis_data_1002)

207

1

);

208

1

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

209

210

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

211

            // with id 100

212

            // TODO: where is that 100 defined?

213

1

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

214

215

1

            run_to_block(2);

216

1

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

217

218

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");

219

220

1

            let genesis_data_1003 = ContainerChainGenesisData {

221

1

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

222

1

                name: Default::default(),

223

1

                id: Default::default(),

224

1

                fork_id: Default::default(),

225

1

                extensions: vec![],

226

1

                properties: Default::default(),

227

1

};

228

1

            assert_ok!(

229

1

                Registrar::register(

230

1

                    origin_of(ALICE.into()),

231

1

                    1003.into(),

232

1

                    genesis_data_1003.clone(),

233

1

                    None

234

1

),

235

1

()

236

1

);

237

238

            // Registered container chains are inserted immediately

239

1

            assert_eq!(

240

1

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

241

1

                Some(&genesis_data_1003)

242

1

);

243

244

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

245

1

            run_to_session(2u32);

246

1

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

247

1

});

248

1

249

250

#[test]

251

1

fn test_author_collation_aura() {

252

1

    ExtBuilder::default()

253

1

        .with_empty_parachains(vec![1001, 1002])

254

1

        .build()

255

1

        .execute_with(|| {

256

1

            run_to_block(5);

257

1

            // Assert current slot gets updated

258

1

            assert_eq!(current_slot(), 4u64);

259

            // slot 4, alice

260

1

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

261

262

1

            run_to_block(6);

263

1

264

1

            assert_eq!(current_slot(), 5u64);

265

            // slot 5, bob

266

1

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

267

1

});

268

1

269

270

#[test]

271

1

fn test_author_collation_aura_change_of_authorities_on_session() {

272

1

    ExtBuilder::default()

273

1

        .with_balances(vec![

274

1

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

275

1

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

276

1

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

277

1

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

278

1

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

279

1

])

280

1

        .with_empty_parachains(vec![1001, 1002])

281

1

        .build()

282

1

        .execute_with(|| {

283

1

            run_to_block(2);

284

1

            // Assert current slot gets updated

285

1

            assert_eq!(current_slot(), 1u64);

286

1

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

287

288

            // We change invulnerables

289

            // We first need to set the keys

290

1

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

291

1

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

292

1

293

1

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

294

1

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

295

1

296

1

            // Set CHARLIE and DAVE keys

297

1

            assert_ok!(Session::set_keys(

298

1

                origin_of(CHARLIE.into()),

299

1

                crate::SessionKeys {

300

1

                    nimbus: charlie_id.clone(),

301

1

},

302

1

                vec![]

303

1

));

304

1

            assert_ok!(Session::set_keys(

305

1

                origin_of(DAVE.into()),

306

1

                crate::SessionKeys {

307

1

                    nimbus: dave_id.clone(),

308

1

},

309

1

                vec![]

310

1

));

311

312

            // Change invulnerables

313

1

            assert_ok!(Invulnerables::remove_invulnerable(

314

1

                root_origin(),

315

1

                ALICE.into()

316

1

));

317

1

            assert_ok!(Invulnerables::remove_invulnerable(

318

1

                root_origin(),

319

1

                BOB.into()

320

1

));

321

1

            assert_ok!(Invulnerables::add_invulnerable(

322

1

                root_origin(),

323

1

                CHARLIE.into()

324

1

));

325

1

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

326

327

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

328

1

            run_to_session(1u32);

329

1

            let author = get_orchestrator_current_author().unwrap();

330

1

331

1

            assert_eq!(current_author(), author);

332

1

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

333

334

            // Invulnerables should have triggered on new session authorities change

335

1

            run_to_session(2u32);

336

1

            let author_after_changes = get_orchestrator_current_author().unwrap();

337

1

338

1

            assert_eq!(current_author(), author_after_changes);

339

1

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

340

1

});

341

1

342

343

#[test]

344

1

fn test_author_collation_aura_add_assigned_to_paras() {

345

1

    ExtBuilder::default()

346

1

        .with_balances(vec![

347

1

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

348

1

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

349

1

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

350

1

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

351

1

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

352

1

])

353

1

        .with_empty_parachains(vec![1001, 1002])

354

1

        .build()

355

1

        .execute_with(|| {

356

1

            run_to_block(2);

357

1

            // Assert current slot gets updated

358

1

            assert_eq!(current_slot(), 1u64);

359

1

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

360

361

            // We change invulnerables

362

            // We first need to set the keys

363

1

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

364

1

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

365

1

366

1

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

367

1

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

368

1

369

1

            // Set CHARLIE and DAVE keys

370

1

            assert_ok!(Session::set_keys(

371

1

                origin_of(CHARLIE.into()),

372

1

                crate::SessionKeys { nimbus: charlie_id },

373

1

                vec![]

374

1

));

375

1

            assert_ok!(Session::set_keys(

376

1

                origin_of(DAVE.into()),

377

1

                crate::SessionKeys { nimbus: dave_id },

378

1

                vec![]

379

1

));

380

381

            // Add new invulnerables

382

1

            assert_ok!(Invulnerables::add_invulnerable(

383

1

                root_origin(),

384

1

                CHARLIE.into()

385

1

));

386

1

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

387

388

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

389

1

            run_to_session(1u32);

390

1

            let author = get_orchestrator_current_author().unwrap();

391

1

392

1

            assert_eq!(current_author(), author);

393

1

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

394

395

            // Invulnerables should have triggered on new session authorities change

396

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

397

1

            run_to_session(2u32);

398

1

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

399

1

            let assignment = CollatorAssignment::collator_container_chain();

400

1

            assert_eq!(

401

1

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

402

1

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

403

1

);

404

1

});

405

1

406

407

#[test]

408

1

fn test_authors_without_paras() {

409

1

    ExtBuilder::default()

410

1

        .with_balances(vec![

411

1

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

412

1

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

413

1

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

414

1

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

415

1

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

416

1

])

417

1

        .with_collators(vec![

418

1

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

419

1

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

420

1

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

421

1

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

422

1

])

423

1

        .build()

424

1

        .execute_with(|| {

425

1

            run_to_block(2);

426

1

            // Assert current slot gets updated

427

1

            assert_eq!(current_slot(), 1u64);

428

1

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

429

430

            // Only Alice and Bob collate for our chain

431

1

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

432

1

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

433

1

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

434

1

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

435

1

436

1

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

437

1

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

438

439

            // Set moondance collators to min 2 max 5

440

1

            assert_ok!(

441

1

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

442

1

()

443

1

);

444

1

            assert_ok!(

445

1

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

446

1

()

447

1

);

448

449

1

            run_to_session(2);

450

1

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

451

1

});

452

1

453

454

#[test]

455

1

fn test_authors_paras_inserted_a_posteriori() {

456

1

    ExtBuilder::default()

457

1

        .with_balances(vec![

458

1

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

459

1

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

460

1

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

461

1

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

462

1

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

463

1

])

464

1

        .with_collators(vec![

465

1

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

466

1

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

467

1

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

468

1

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

469

1

])

470

1

        .build()

471

1

        .execute_with(|| {

472

1

            run_to_block(2);

473

1

            // Assert current slot gets updated

474

1

            assert_eq!(current_slot(), 1u64);

475

1

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

476

477

            // Alice and Bob collate in our chain

478

1

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

479

1

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

480

1

481

1

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

482

483

1

            assert_ok!(Registrar::register(

484

1

                origin_of(ALICE.into()),

485

1

                1001.into(),

486

1

                empty_genesis_data(),

487

1

                None

488

1

));

489

1

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

490

1

            assert_ok!(Registrar::mark_valid_for_collating(

491

1

                root_origin(),

492

1

                1001.into()

493

1

));

494

1

            assert_ok!(ServicesPayment::purchase_credits(

495

1

                origin_of(ALICE.into()),

496

1

                1001.into(),

497

1

                block_credits_to_required_balance(1000, 1001.into())

498

1

));

499

1

            assert_ok!(Registrar::register(

500

1

                origin_of(ALICE.into()),

501

1

                1002.into(),

502

1

                empty_genesis_data(),

503

1

                None

504

1

));

505

1

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

506

1

            assert_ok!(Registrar::mark_valid_for_collating(

507

1

                root_origin(),

508

1

                1002.into()

509

1

));

510

1

            assert_ok!(ServicesPayment::purchase_credits(

511

1

                origin_of(ALICE.into()),

512

1

                1002.into(),

513

1

                block_credits_to_required_balance(1000, 1002.into())

514

1

));

515

516

            // Assignment should happen after 2 sessions

517

1

            run_to_session(1u32);

518

1

            let assignment = CollatorAssignment::collator_container_chain();

519

1

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

520

1

            run_to_session(2u32);

521

1

522

1

            // Charlie and Dave should be assigned to para 1001

523

1

            let assignment = CollatorAssignment::collator_container_chain();

524

1

            assert_eq!(

525

1

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

526

1

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

527

1

);

528

1

});

529

1

530

531

#[test]

532

1

fn test_authors_paras_inserted_a_posteriori_with_collators_already_assigned() {

533

1

    ExtBuilder::default()

534

1

        .with_balances(vec![

535

1

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

536

1

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

537

1

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

538

1

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

539

1

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

540

1

])

541

1

        .with_collators(vec![

542

1

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

543

1

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

544

1

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

545

1

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

546

1

])

547

1

        .with_config(pallet_configuration::HostConfiguration {

548

1

            max_collators: 100,

549

1

            min_orchestrator_collators: 2,

550

1

            max_orchestrator_collators: 5,

551

1

            collators_per_container: 2,

552

1

            full_rotation_period: 24,

553

1

            ..Default::default()

554

1

})

555

1

        .build()

556

1

        .execute_with(|| {

557

1

            run_to_block(2);

558

1

            // Assert current slot gets updated

559

1

            assert_eq!(current_slot(), 1u64);

560

1

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

561

562

            // Alice and Bob collate in our chain

563

1

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

564

1

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

565

1

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

566

1

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

567

1

568

1

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

569

570

1

            assert_ok!(Registrar::register(

571

1

                origin_of(ALICE.into()),

572

1

                1001.into(),

573

1

                empty_genesis_data(),

574

1

                None

575

1

));

576

1

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

577

1

            assert_ok!(Registrar::mark_valid_for_collating(

578

1

                root_origin(),

579

1

                1001.into()

580

1

));

581

1

            assert_ok!(ServicesPayment::purchase_credits(

582

1

                origin_of(ALICE.into()),

583

1

                1001.into(),

584

1

                block_credits_to_required_balance(1000, 1001.into())

585

1

));

586

587

            // Assignment should happen after 2 sessions

588

1

            run_to_session(1u32);

589

1

            let assignment = CollatorAssignment::collator_container_chain();

590

1

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

591

1

            run_to_session(2u32);

592

1

593

1

            // Charlie and Dave are now assigned to para 1001

594

1

            let assignment = CollatorAssignment::collator_container_chain();

595

1

            assert_eq!(

596

1

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

597

1

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

598

1

);

599

1

            assert_eq!(

600

1

                assignment.orchestrator_chain,

601

1

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

602

1

);

603

1

});

604

1

605

606

#[test]

607

1

fn test_paras_registered_but_zero_credits() {

608

1

    ExtBuilder::default()

609

1

        .with_balances(vec![

610

1

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

611

1

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

612

1

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

613

1

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

614

1

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

615

1

])

616

1

        .with_collators(vec![

617

1

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

618

1

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

619

1

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

620

1

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

621

1

])

622

1

        .build()

623

1

        .execute_with(|| {

624

1

            run_to_block(2);

625

1

            // Assert current slot gets updated

626

1

            assert_eq!(current_slot(), 1u64);

627

1

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

628

629

            // Alice and Bob collate in our chain

630

1

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

631

1

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

632

1

633

1

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

634

635

1

            assert_ok!(Registrar::register(

636

1

                origin_of(ALICE.into()),

637

1

                1001.into(),

638

1

                empty_genesis_data(),

639

1

                None

640

1

));

641

1

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

642

1

            assert_ok!(Registrar::mark_valid_for_collating(

643

1

                root_origin(),

644

1

                1001.into()

645

1

));

646

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

647

1

            assert_ok!(ServicesPayment::set_block_production_credits(

648

1

                root_origin(),

649

1

                1001.into(),

650

1

651

1

));

652

653

            // Assignment should happen after 2 sessions

654

1

            run_to_session(1u32);

655

1

            let assignment = CollatorAssignment::collator_container_chain();

656

1

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

657

1

            run_to_session(2u32);

658

1

659

1

            // Nobody should be assigned to para 1001

660

1

            let assignment = CollatorAssignment::collator_container_chain();

661

1

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

662

1

});

663

1

664

665

#[test]

666

1

fn test_paras_registered_but_not_enough_credits() {

667

1

    ExtBuilder::default()

668

1

        .with_balances(vec![

669

1

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

670

1

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

671

1

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

672

1

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

673

1

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

674

1

])

675

1

        .with_collators(vec![

676

1

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

677

1

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

678

1

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

679

1

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

680

1

])

681

1

        .build()

682

1

        .execute_with(|| {

683

1

            run_to_block(2);

684

1

            // Assert current slot gets updated

685

1

            assert_eq!(current_slot(), 1u64);

686

1

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

687

688

            // Alice and Bob collate in our chain

689

1

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

690

1

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

691

1

692

1

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

693

694

1

            assert_ok!(Registrar::register(

695

1

                origin_of(ALICE.into()),

696

1

                1001.into(),

697

1

                empty_genesis_data(),

698

1

                None

699

1

));

700

1

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

701

1

            assert_ok!(Registrar::mark_valid_for_collating(

702

1

                root_origin(),

703

1

                1001.into()

704

1

));

705

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

706

1

            assert_ok!(ServicesPayment::set_block_production_credits(

707

1

                root_origin(),

708

1

                1001.into(),

709

1

710

1

));

711

            // Purchase 1 credit less that what is needed

712

1

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

713

1

            assert_ok!(ServicesPayment::set_block_production_credits(

714

1

                root_origin(),

715

1

                1001.into(),

716

1

                credits_1001

717

1

));

718

719

            // Assignment should happen after 2 sessions

720

1

            run_to_session(1u32);

721

1

            let assignment = CollatorAssignment::collator_container_chain();

722

1

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

723

1

            run_to_session(2u32);

724

1

            // Nobody should be assigned to para 1001

725

1

            let assignment = CollatorAssignment::collator_container_chain();

726

1

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

727

728

            // Now purchase the missing block credit

729

1

            assert_ok!(ServicesPayment::set_block_production_credits(

730

1

                root_origin(),

731

1

                1001.into(),

732

1

                credits_1001 + 1

733

1

));

734

735

1

            run_to_session(4u32);

736

1

            // Charlie and Dave should be assigned to para 1001

737

1

            let assignment = CollatorAssignment::collator_container_chain();

738

1

            assert_eq!(

739

1

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

740

1

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

741

1

);

742

1

});

743

1

744

745

#[test]

746

1

fn test_paras_registered_but_only_credits_for_1_session() {

747

1

    ExtBuilder::default()

748

1

        .with_balances(vec![

749

1

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

750

1

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

751

1

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

752

1

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

753

1

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

754

1

])

755

1

        .with_collators(vec![

756

1

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

757

1

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

758

1

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

759

1

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

760

1

])

761

1

        .build()

762

1

        .execute_with(|| {

763

1

            run_to_block(2);

764

1

            // Assert current slot gets updated

765

1

            assert_eq!(current_slot(), 1u64);

766

1

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

767

768

            // Alice and Bob collate in our chain

769

1

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

770

1

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

771

1

772

1

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

773

774

1

            assert_ok!(Registrar::register(

775

1

                origin_of(ALICE.into()),

776

1

                1001.into(),

777

1

                empty_genesis_data(),

778

1

                None

779

1

));

780

1

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

781

1

            assert_ok!(Registrar::mark_valid_for_collating(

782

1

                root_origin(),

783

1

                1001.into()

784

1

));

785

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

786

1

            assert_ok!(ServicesPayment::set_block_production_credits(

787

1

                root_origin(),

788

1

                1001.into(),

789

1

790

1

));

791

            // Purchase only enough credits for 1 session

792

1

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

793

1

            assert_ok!(ServicesPayment::set_block_production_credits(

794

1

                root_origin(),

795

1

                1001.into(),

796

1

                credits_1001

797

1

));

798

799

            // Assignment should happen after 2 sessions

800

1

            run_to_session(1u32);

801

1

            let assignment = CollatorAssignment::collator_container_chain();

802

1

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

803

1

            run_to_session(2u32);

804

1

            // Charlie and Dave should be assigned to para 1001

805

1

            let assignment = CollatorAssignment::collator_container_chain();

806

1

            assert_eq!(

807

1

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

808

1

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

809

1

);

810

811

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

812

1

            run_block();

813

1

            let credits =

814

1

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

815

1

                    .unwrap_or_default();

816

1

            assert_eq!(credits, credits_1001);

817

818

            // Simulate block inclusion from container chain 1001

819

1

            let mut sproof = ParaHeaderSproofBuilder::default();

820

1

            let slot: u64 = 5;

821

1

            let s = ParaHeaderSproofBuilderItem {

822

1

                para_id: 1001.into(),

823

1

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

824

1

                    parent_hash: Default::default(),

825

1

                    number: 1,

826

1

                    state_root: Default::default(),

827

1

                    extrinsics_root: Default::default(),

828

1

                    digest: sp_runtime::generic::Digest {

829

1

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

830

1

},

831

1

}),

832

1

};

833

1

            sproof.items.push(s);

834

1

            set_author_noting_inherent_data(sproof);

835

1

836

1

            run_block();

837

1

            let credits =

838

1

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

839

1

                    .unwrap_or_default();

840

1

            assert_eq!(credits, credits_1001 - 1);

841

842

1

            run_to_session(4u32);

843

1

            // Nobody should be assigned to para 1001

844

1

            let assignment = CollatorAssignment::collator_container_chain();

845

1

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

846

847

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

848

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

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

1

});

854

1

855

856

#[test]

857

1

fn test_parachains_deregister_collators_re_assigned() {

858

1

    ExtBuilder::default()

859

1

        .with_balances(vec![

860

1

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

861

1

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

862

1

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

863

1

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

864

1

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

865

1

])

866

1

        .with_collators(vec![

867

1

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

868

1

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

869

1

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

870

1

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

871

1

])

872

1

        .with_empty_parachains(vec![1001, 1002])

873

1

        .build()

874

1

        .execute_with(|| {

875

1

            run_to_block(2);

876

1

            // Assert current slot gets updated

877

1

            assert_eq!(current_slot(), 1u64);

878

1

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

879

880

            // Alice and Bob are authorities

881

1

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

882

1

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

883

1

884

1

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

885

886

            // Charlie and Dave to 1001

887

1

            let assignment = CollatorAssignment::collator_container_chain();

888

1

            assert_eq!(

889

1

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

890

1

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

891

1

);

892

893

1

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

894

895

            // Assignment should happen after 2 sessions

896

1

            run_to_session(1u32);

897

1

898

1

            let assignment = CollatorAssignment::collator_container_chain();

899

1

            assert_eq!(

900

1

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

901

1

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

902

1

);

903

904

1

            run_to_session(2u32);

905

1

906

1

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

907

1

            let assignment = CollatorAssignment::collator_container_chain();

908

1

            assert_eq!(

909

1

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

910

1

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

911

1

);

912

1

});

913

1

914

915

#[test]

916

1

fn test_parachains_deregister_collators_config_change_reassigned() {

917

1

    ExtBuilder::default()

918

1

        .with_balances(vec![

919

1

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

920

1

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

921

1

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

922

1

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

923

1

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

924

1

])

925

1

        .with_collators(vec![

926

1

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

927

1

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

928

1

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

929

1

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

930

1

])

931

1

        .with_empty_parachains(vec![1001, 1002])

932

1

        .build()

933

1

        .execute_with(|| {

934

1

            run_to_block(2);

935

1

            // Assert current slot gets updated

936

1

            assert_eq!(current_slot(), 1u64);

937

1

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

938

939

            // Alice and Bob are authorities

940

1

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

941

1

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

942

1

943

1

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

944

945

            // Set orchestrator collators to 1

946

1

            assert_ok!(

947

1

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

948

1

()

949

1

);

950

951

            // Set container chain collators to 3

952

1

            assert_ok!(

953

1

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

954

1

()

955

1

);

956

957

            // Charlie and Dave to 1001

958

1

            let assignment = CollatorAssignment::collator_container_chain();

959

1

            assert_eq!(

960

1

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

961

1

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

962

1

);

963

964

            // Assignment should happen after 2 sessions

965

1

            run_to_session(1u32);

966

1

967

1

            let assignment = CollatorAssignment::collator_container_chain();

968

1

            assert_eq!(

969

1

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

970

1

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

971

1

);

972

973

1

            run_to_session(2u32);

974

1

975

1

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

976

1

            let assignment = CollatorAssignment::collator_container_chain();

977

1

            assert_eq!(

978

1

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

979

1

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

980

1

);

981

982

1

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

983

1

});

984

1

985

986

#[test]

987

1

fn test_orchestrator_collators_with_non_sufficient_collators() {

988

1

    ExtBuilder::default()

989

1

        .with_balances(vec![

990

1

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

991

1

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

992

1

])

993

1

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

994

1

        .with_empty_parachains(vec![1001, 1002])

995

1

        .build()

996

1

        .execute_with(|| {

997

1

            run_to_block(2);

998

1

            // Assert current slot gets updated

999

1

            assert_eq!(current_slot(), 1u64);

1000

1

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

1001

1002

            // Alice and Bob are authorities

1003

1

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

1004

1

1005

1

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

1006

1

});

1007

1

1008

1009

#[test]

1010

1

fn test_configuration_on_session_change() {

1011

1

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

1012

1

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

1013

1

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

1014

1

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

1015

1016

1

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

1017

1

        run_to_session(1u32);

1018

1

1019

1

        assert_ok!(

1020

1

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

1021

1

()

1022

1

);

1023

1

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

1024

1

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

1025

1

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

1026

1027

1

        run_to_session(2u32);

1028

1

        assert_ok!(

1029

1

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

1030

1

()

1031

1

);

1032

1

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

1033

1

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

1034

1

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

1035

1036

1

        run_to_session(3u32);

1037

1

1038

1

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

1039

1

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

1040

1

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

1041

1042

1

        run_to_session(4u32);

1043

1

1044

1

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

1045

1

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

1046

1

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

1047

1

});

1048

1

1049

1050

#[test]

1051

1

fn test_author_collation_aura_add_assigned_to_paras_runtime_api() {

1052

1

    ExtBuilder::default()

1053

1

        .with_balances(vec![

1054

1

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

1055

1

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

1056

1

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

1057

1

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

1058

1

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

1059

1

])

1060

1

        .with_empty_parachains(vec![1001, 1002])

1061

1

        .build()

1062

1

        .execute_with(|| {

1063

1

            run_to_block(2);

1064

1

            // Assert current slot gets updated

1065

1

            assert_eq!(current_slot(), 1u64);

1066

1

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

1067

1

            assert_eq!(

1068

1

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

1069

1

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

1070

1

);

1071

1

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

1072

1

            assert_eq!(

1073

1

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

1074

1

                Some(100.into())

1075

1

);

1076

1

            assert_eq!(

1077

1

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

1078

1

                Some(100.into())

1079

1

);

1080

1

            assert_eq!(

1081

1

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

1082

1

                None

1083

1

);

1084

1

            assert_eq!(

1085

1

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

1086

1

                None

1087

1

);

1088

1089

            // We change invulnerables

1090

            // We first need to set the keys

1091

1

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

1092

1

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

1093

1

1094

1

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

1095

1

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

1096

1

1097

1

            // Set CHARLIE and DAVE keys

1098

1

            assert_ok!(Session::set_keys(

1099

1

                origin_of(CHARLIE.into()),

1100

1

                crate::SessionKeys { nimbus: charlie_id },

1101

1

                vec![]

1102

1

));

1103

1

            assert_ok!(Session::set_keys(

1104

1

                origin_of(DAVE.into()),

1105

1

                crate::SessionKeys { nimbus: dave_id },

1106

1

                vec![]

1107

1

));

1108

1109

            // Set new invulnerables

1110

1

            assert_ok!(Invulnerables::add_invulnerable(

1111

1

                root_origin(),

1112

1

                CHARLIE.into()

1113

1

));

1114

1

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

1115

1116

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

1117

1

            run_to_session(1u32);

1118

1

            let author = get_orchestrator_current_author().unwrap();

1119

1

1120

1

            assert_eq!(current_author(), author);

1121

1

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

1122

1

            assert_eq!(

1123

1

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

1124

1

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

1125

1

);

1126

1

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

1127

1

            assert_eq!(

1128

1

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

1129

1

                None

1130

1

);

1131

1

            assert_eq!(

1132

1

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

1133

1

                Some(1001.into())

1134

1

);

1135

1136

            // Invulnerables should have triggered on new session authorities change

1137

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

1138

1

            run_to_session(2u32);

1139

1

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

1140

1

            let assignment = CollatorAssignment::collator_container_chain();

1141

1

            assert_eq!(

1142

1

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

1143

1

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

1144

1

);

1145

1146

1

            assert_eq!(

1147

1

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

1148

1

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

1149

1

);

1150

1

            assert_eq!(

1151

1

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

1152

1

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

1153

1

);

1154

1

            assert_eq!(

1155

1

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

1156

1

                Some(1001.into())

1157

1

);

1158

1

            assert_eq!(

1159

1

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

1160

1

                Some(1001.into())

1161

1

);

1162

1163

            // Remove BOB

1164

1

            assert_ok!(Invulnerables::remove_invulnerable(

1165

1

                root_origin(),

1166

1

                BOB.into()

1167

1

));

1168

1169

1

            run_to_session(3u32);

1170

1

            assert_eq!(

1171

1

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

1172

1

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

1173

1

);

1174

1

            assert_eq!(

1175

1

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

1176

1

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

1177

1

);

1178

1

            assert_eq!(

1179

1

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

1180

1

                Some(100.into())

1181

1

);

1182

1

            assert_eq!(

1183

1

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

1184

1

                None

1185

1

);

1186

1187

1

            run_to_session(4u32);

1188

1

            assert_eq!(

1189

1

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

1190

1

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

1191

1

);

1192

1

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

1193

1

            assert_eq!(

1194

1

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

1195

1

                None

1196

1

);

1197

1

            assert_eq!(

1198

1

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

1199

1

                None

1200

1

);

1201

1

});

1202

1

1203

1204

#[test]

1205

1

fn test_consensus_runtime_api() {

1206

1

    ExtBuilder::default()

1207

1

        .with_balances(vec![

1208

1

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

1209

1

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

1210

1

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

1211

1

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

1212

1

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

1213

1

])

1214

1

        .with_empty_parachains(vec![1001, 1002])

1215

1

        .build()

1216

1

        .execute_with(|| {

1217

1

            run_to_block(2);

1218

1

1219

1

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

1220

1

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

1221

1

1222

1

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

1223

1

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

1224

1

1225

1

            assert_eq!(

1226

1

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

1227

1

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

1228

1

);

1229

1

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

1230

1

            assert_eq!(

1231

1

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

1232

1

                Some(100.into())

1233

1

);

1234

1

            assert_eq!(

1235

1

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

1236

1

                Some(100.into())

1237

1

);

1238

1

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

1239

1

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

1240

1241

            // Set CHARLIE and DAVE keys

1242

1

            assert_ok!(Session::set_keys(

1243

1

                origin_of(CHARLIE.into()),

1244

1

                crate::SessionKeys {

1245

1

                    nimbus: charlie_id.clone(),

1246

1

},

1247

1

                vec![]

1248

1

));

1249

1

            assert_ok!(Session::set_keys(

1250

1

                origin_of(DAVE.into()),

1251

1

                crate::SessionKeys {

1252

1

                    nimbus: dave_id.clone(),

1253

1

},

1254

1

                vec![]

1255

1

));

1256

1257

            // Set new invulnerables

1258

1

            assert_ok!(Invulnerables::add_invulnerable(

1259

1

                root_origin(),

1260

1

                CHARLIE.into()

1261

1

));

1262

1

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

1263

1264

1

            run_to_session(2u32);

1265

1

            assert_eq!(

1266

1

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

1267

1

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

1268

1

);

1269

1

            assert_eq!(

1270

1

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

1271

1

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

1272

1

);

1273

1

            assert_eq!(

1274

1

                Runtime::check_para_id_assignment(alice_id),

1275

1

                Some(100.into())

1276

1

);

1277

1

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

1278

1

            assert_eq!(

1279

1

                Runtime::check_para_id_assignment(charlie_id),

1280

1

                Some(1001.into())

1281

1

);

1282

1

            assert_eq!(

1283

1

                Runtime::check_para_id_assignment(dave_id),

1284

1

                Some(1001.into())

1285

1

);

1286

1

});

1287

1

1288

1289

#[test]

1290

1

fn test_consensus_runtime_api_session_changes() {

1291

1

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

1292

1

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

1293

1

    // if we can predict correctly

1294

1

    ExtBuilder::default()

1295

1

        .with_balances(vec![

1296

1

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

1297

1

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

1298

1

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

1299

1

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

1300

1

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

1301

1

])

1302

1

        .with_empty_parachains(vec![1001, 1002])

1303

1

        .build()

1304

1

        .execute_with(|| {

1305

1

            run_to_block(2);

1306

1

1307

1

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

1308

1

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

1309

1

1310

1

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

1311

1

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

1312

1

1313

1

            assert_eq!(

1314

1

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

1315

1

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

1316

1

);

1317

1

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

1318

1

            assert_eq!(

1319

1

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

1320

1

                Some(100.into())

1321

1

);

1322

1

            assert_eq!(

1323

1

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

1324

1

                Some(100.into())

1325

1

);

1326

1

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

1327

1

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

1328

1329

            // Set CHARLIE and DAVE keys

1330

1

            assert_ok!(Session::set_keys(

1331

1

                origin_of(CHARLIE.into()),

1332

1

                crate::SessionKeys {

1333

1

                    nimbus: charlie_id.clone(),

1334

1

},

1335

1

                vec![]

1336

1

));

1337

1

            assert_ok!(Session::set_keys(

1338

1

                origin_of(DAVE.into()),

1339

1

                crate::SessionKeys {

1340

1

                    nimbus: dave_id.clone(),

1341

1

},

1342

1

                vec![]

1343

1

));

1344

1345

            // Set new invulnerables

1346

1

            assert_ok!(Invulnerables::add_invulnerable(

1347

1

                root_origin(),

1348

1

                CHARLIE.into()

1349

1

));

1350

1

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

1351

1352

1

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

1353

1

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

1354

1

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

1355

1

            // edge of a session change

1356

1

            run_to_block(session_two_edge - 2);

1357

1

1358

1

            assert_eq!(

1359

1

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

1360

1

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

1361

1

);

1362

1

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

1363

1

            assert_eq!(

1364

1

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

1365

1

                Some(100.into())

1366

1

);

1367

1

            assert_eq!(

1368

1

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

1369

1

                Some(100.into())

1370

1

);

1371

1

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

1372

1

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

1373

1374

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

1375

            // authorities of the next block!

1376

1

            run_to_block(session_two_edge - 1);

1377

1

            assert_eq!(

1378

1

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

1379

1

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

1380

1

);

1381

1

            assert_eq!(

1382

1

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

1383

1

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

1384

1

);

1385

1

            assert_eq!(

1386

1

                Runtime::check_para_id_assignment(alice_id),

1387

1

                Some(100.into())

1388

1

);

1389

1

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

1390

1

            assert_eq!(

1391

1

                Runtime::check_para_id_assignment(charlie_id),

1392

1

                Some(1001.into())

1393

1

);

1394

1

            assert_eq!(

1395

1

                Runtime::check_para_id_assignment(dave_id),

1396

1

                Some(1001.into())

1397

1

);

1398

1

});

1399

1

1400

1401

#[test]

1402

1

fn test_consensus_runtime_api_next_session() {

1403

1

    ExtBuilder::default()

1404

1

        .with_balances(vec![

1405

1

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

1406

1

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

1407

1

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

1408

1

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

1409

1

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

1410

1

])

1411

1

        .with_empty_parachains(vec![1001, 1002])

1412

1

        .build()

1413

1

        .execute_with(|| {

1414

1

            run_to_block(2);

1415

1

1416

1

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

1417

1

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

1418

1

1419

1

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

1420

1

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

1421

1

1422

1

            assert_eq!(

1423

1

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

1424

1

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

1425

1

);

1426

1

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

1427

1

            assert_eq!(

1428

1

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

1429

1

                Some(100.into())

1430

1

);

1431

1

            assert_eq!(

1432

1

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

1433

1

                Some(100.into())

1434

1

);

1435

1

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

1436

1

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

1437

1438

            // In the next session the assignment will not change

1439

1

            assert_eq!(

1440

1

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

1441

1

                Some(100.into())

1442

1

);

1443

1

            assert_eq!(

1444

1

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

1445

1

                Some(100.into())

1446

1

);

1447

1

            assert_eq!(

1448

1

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

1449

1

                None,

1450

1

);

1451

1

            assert_eq!(

1452

1

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

1453

1

                None,

1454

1

);

1455

1456

            // Set CHARLIE and DAVE keys

1457

1

            assert_ok!(Session::set_keys(

1458

1

                origin_of(CHARLIE.into()),

1459

1

                crate::SessionKeys {

1460

1

                    nimbus: charlie_id.clone(),

1461

1

},

1462

1

                vec![]

1463

1

));

1464

1

            assert_ok!(Session::set_keys(

1465

1

                origin_of(DAVE.into()),

1466

1

                crate::SessionKeys {

1467

1

                    nimbus: dave_id.clone(),

1468

1

},

1469

1

                vec![]

1470

1

));

1471

1472

            // Set new invulnerables

1473

1

            assert_ok!(Invulnerables::add_invulnerable(

1474

1

                root_origin(),

1475

1

                CHARLIE.into()

1476

1

));

1477

1

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

1478

1479

1

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

1480

1

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

1481

1

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

1482

1

            // edge of a session change

1483

1

            run_to_block(session_two_edge - 2);

1484

1

1485

1

            assert_eq!(

1486

1

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

1487

1

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

1488

1

);

1489

1

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

1490

1

            assert_eq!(

1491

1

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

1492

1

                Some(100.into())

1493

1

);

1494

1

            assert_eq!(

1495

1

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

1496

1

                Some(100.into())

1497

1

);

1498

1

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

1499

1

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

1500

1501

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

1502

1

            assert_eq!(

1503

1

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

1504

1

                Some(100.into())

1505

1

);

1506

1

            assert_eq!(

1507

1

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

1508

1

                Some(100.into())

1509

1

);

1510

1

            assert_eq!(

1511

1

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

1512

1

                Some(1001.into()),

1513

1

);

1514

1

            assert_eq!(

1515

1

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

1516

1

                Some(1001.into()),

1517

1

);

1518

1519

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

1520

            // authorities of the next block!

1521

1

            run_to_block(session_two_edge - 1);

1522

1

            assert_eq!(

1523

1

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

1524

1

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

1525

1

);

1526

1

            assert_eq!(

1527

1

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

1528

1

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

1529

1

);

1530

1

            assert_eq!(

1531

1

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

1532

1

                Some(100.into())

1533

1

);

1534

1

            assert_eq!(

1535

1

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

1536

1

                Some(100.into())

1537

1

);

1538

1

            assert_eq!(

1539

1

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

1540

1

                Some(1001.into())

1541

1

);

1542

1

            assert_eq!(

1543

1

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

1544

1

                Some(1001.into())

1545

1

);

1546

1547

            // check_para_id_assignment_next_session returns the same value as check_para_id_assignment

1548

            // because we are on a session boundary

1549

1

            assert_eq!(

1550

1

                Runtime::check_para_id_assignment_next_session(alice_id),

1551

1

                Some(100.into())

1552

1

);

1553

1

            assert_eq!(

1554

1

                Runtime::check_para_id_assignment_next_session(bob_id),

1555

1

                Some(100.into())

1556

1

);

1557

1

            assert_eq!(

1558

1

                Runtime::check_para_id_assignment_next_session(charlie_id),

1559

1

                Some(1001.into())

1560

1

);

1561

1

            assert_eq!(

1562

1

                Runtime::check_para_id_assignment_next_session(dave_id),

1563

1

                Some(1001.into())

1564

1

);

1565

1

});

1566

1

1567

1568

#[test]

1569

1

fn test_author_noting_self_para_id_not_noting() {

1570

1

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

1571

1

        let mut sproof = ParaHeaderSproofBuilder::default();

1572

1

        let slot: u64 = 5;

1573

1

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

1574

1

        let s = ParaHeaderSproofBuilderItem {

1575

1

            para_id: self_para,

1576

1

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

1577

1

                parent_hash: Default::default(),

1578

1

                number: Default::default(),

1579

1

                state_root: Default::default(),

1580

1

                extrinsics_root: Default::default(),

1581

1

                digest: sp_runtime::generic::Digest {

1582

1

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

1583

1

},

1584

1

}),

1585

1

};

1586

1

        sproof.items.push(s);

1587

1

1588

1

        set_author_noting_inherent_data(sproof);

1589

1

1590

1

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

1591

1

});

1592

1

1593

1594

#[test]

1595

1

fn test_author_noting_not_self_para() {

1596

1

    ExtBuilder::default()

1597

1

        .with_balances(vec![

1598

1

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

1599

1

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

1600

1

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

1601

1

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

1602

1

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

1603

1

])

1604

1

        .with_collators(vec![

1605

1

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

1606

1

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

1607

1

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

1608

1

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

1609

1

])

1610

1

        .with_empty_parachains(vec![1001, 1002])

1611

1

        .build()

1612

1

        .execute_with(|| {

1613

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1614

1

            let slot: u64 = 5;

1615

1

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

1616

1

1617

1

            // Charlie and Dave to 1001

1618

1

            let assignment = CollatorAssignment::collator_container_chain();

1619

1

            assert_eq!(

1620

1

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

1621

1

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

1622

1

);

1623

1624

1

            let s = ParaHeaderSproofBuilderItem {

1625

1

                para_id: other_para,

1626

1

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

1627

1

                    parent_hash: Default::default(),

1628

1

                    number: 1,

1629

1

                    state_root: Default::default(),

1630

1

                    extrinsics_root: Default::default(),

1631

1

                    digest: sp_runtime::generic::Digest {

1632

1

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

1633

1

},

1634

1

}),

1635

1

};

1636

1

            sproof.items.push(s);

1637

1

1638

1

            set_author_noting_inherent_data(sproof);

1639

1

1640

1

            assert_eq!(

1641

1

                AuthorNoting::latest_author(other_para),

1642

1

                Some(ContainerChainBlockInfo {

1643

1

                    block_number: 1,

1644

1

                    author: AccountId::from(DAVE),

1645

1

                    latest_slot_number: 0.into(),

1646

1

})

1647

1

);

1648

1

});

1649

1

1650

1651

#[test]

1652

1

fn test_author_noting_set_author_and_kill_author_data() {

1653

1

    ExtBuilder::default()

1654

1

        .with_balances(vec![

1655

1

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

1656

1

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

1657

1

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

1658

1

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

1659

1

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

1660

1

])

1661

1

        .with_collators(vec![

1662

1

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

1663

1

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

1664

1

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

1665

1

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

1666

1

])

1667

1

        .with_empty_parachains(vec![1001, 1002])

1668

1

        .build()

1669

1

        .execute_with(|| {

1670

1

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

1671

1

1672

1

            assert_ok!(AuthorNoting::set_author(

1673

1

                root_origin(),

1674

1

                other_para,

1675

1

1,

1676

1

                AccountId::from(DAVE),

1677

1

                1.into()

1678

1

));

1679

1680

1

            assert_eq!(

1681

1

                AuthorNoting::latest_author(other_para),

1682

1

                Some(ContainerChainBlockInfo {

1683

1

                    block_number: 1,

1684

1

                    author: AccountId::from(DAVE),

1685

1

                    latest_slot_number: 1.into(),

1686

1

})

1687

1

);

1688

1689

1

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

1690

1691

1

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

1692

1

});

1693

1

1694

1695

#[test]

1696

1

fn test_author_noting_set_author_and_kill_author_data_bad_origin() {

1697

1

    ExtBuilder::default()

1698

1

        .with_balances(vec![

1699

1

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

1700

1

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

1701

1

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

1702

1

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

1703

1

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

1704

1

])

1705

1

        .with_collators(vec![

1706

1

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

1707

1

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

1708

1

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

1709

1

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

1710

1

])

1711

1

        .with_empty_parachains(vec![1001, 1002])

1712

1

        .build()

1713

1

        .execute_with(|| {

1714

1

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

1715

1

1716

1

            assert_noop!(

1717

1

                AuthorNoting::set_author(

1718

1

                    origin_of(ALICE.into()),

1719

1

                    other_para,

1720

1

1,

1721

1

                    AccountId::from(DAVE),

1722

1

                    1.into()

1723

1

),

1724

1

                BadOrigin

1725

1

);

1726

1727

1

            assert_noop!(

1728

1

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

1729

1

                BadOrigin

1730

1

);

1731

1

});

1732

1

1733

1734

#[test]

1735

1

fn test_author_noting_runtime_api() {

1736

1

    ExtBuilder::default()

1737

1

        .with_balances(vec![

1738

1

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

1739

1

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

1740

1

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

1741

1

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

1742

1

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

1743

1

])

1744

1

        .with_collators(vec![

1745

1

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

1746

1

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

1747

1

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

1748

1

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

1749

1

])

1750

1

        .with_empty_parachains(vec![1001, 1002])

1751

1

        .build()

1752

1

        .execute_with(|| {

1753

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1754

1

            let slot: u64 = 5;

1755

1

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

1756

1

1757

1

            // Charlie and Dave to 1001

1758

1

            let assignment = CollatorAssignment::collator_container_chain();

1759

1

            assert_eq!(

1760

1

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

1761

1

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

1762

1

);

1763

1764

1

            let s = ParaHeaderSproofBuilderItem {

1765

1

                para_id: other_para,

1766

1

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

1767

1

                    parent_hash: Default::default(),

1768

1

                    number: 1,

1769

1

                    state_root: Default::default(),

1770

1

                    extrinsics_root: Default::default(),

1771

1

                    digest: sp_runtime::generic::Digest {

1772

1

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

1773

1

},

1774

1

}),

1775

1

};

1776

1

            sproof.items.push(s);

1777

1

1778

1

            set_author_noting_inherent_data(sproof);

1779

1

1780

1

            assert_eq!(

1781

1

                AuthorNoting::latest_author(other_para),

1782

1

                Some(ContainerChainBlockInfo {

1783

1

                    block_number: 1,

1784

1

                    author: AccountId::from(DAVE),

1785

1

                    latest_slot_number: 0.into(),

1786

1

})

1787

1

);

1788

1789

1

            assert_eq!(

1790

1

                Runtime::latest_author(other_para),

1791

1

                Some(AccountId::from(DAVE))

1792

1

);

1793

1

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

1794

1

});

1795

1

1796

1797

#[test]

1798

1

fn test_collator_assignment_rotation() {

1799

1

    ExtBuilder::default()

1800

1

        .with_balances(vec![

1801

1

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

1802

1

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

1803

1

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

1804

1

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

1805

1

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

1806

1

])

1807

1

        .with_collators(vec![

1808

1

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

1809

1

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

1810

1

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

1811

1

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

1812

1

])

1813

1

        .with_empty_parachains(vec![1001, 1002])

1814

1

        .build()

1815

1

        .execute_with(|| {

1816

1

            // Charlie and Dave to 1001

1817

1

            let assignment = CollatorAssignment::collator_container_chain();

1818

1

            let initial_assignment = assignment.clone();

1819

1

            assert_eq!(

1820

1

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

1821

1

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

1822

1

);

1823

1824

1

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

1825

1

            run_to_session(rotation_period - 2);

1826

1

            set_parachain_inherent_data_random_seed([1; 32]);

1827

1

            run_block();

1828

1

1829

1

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

1830

1831

1

            run_to_session(rotation_period - 1);

1832

1

            assert_eq!(

1833

1

                CollatorAssignment::collator_container_chain(),

1834

1

                initial_assignment,

1835

1

);

1836

1

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

1837

1838

1

            run_to_session(rotation_period);

1839

1

            // Assignment changed

1840

1

            assert_ne!(

1841

1

                CollatorAssignment::collator_container_chain(),

1842

1

                initial_assignment,

1843

1

);

1844

1

});

1845

1

1846

1847

#[test]

1848

1

fn session_keys_key_type_id() {

1849

1

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

1850

1

1851

1852

#[test]

1853

1

fn test_session_keys_with_authority_mapping() {

1854

1

    ExtBuilder::default()

1855

1

        .with_balances(vec![

1856

1

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

1857

1

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

1858

1

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

1859

1

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

1860

1

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

1861

1

])

1862

1

        .with_empty_parachains(vec![1001, 1002])

1863

1

        .build()

1864

1

        .execute_with(|| {

1865

1

            run_to_block(2);

1866

1

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

1867

1

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

1868

1

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

1869

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1870

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1871

1

1872

1

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

1873

1

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

1874

1

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

1875

1876

            // Everything should match to aura

1877

1

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

1878

1879

            // Change Alice and Bob keys to something different

1880

            // for now lets change it to alice_2 and bob_2

1881

1

            assert_ok!(Session::set_keys(

1882

1

                origin_of(ALICE.into()),

1883

1

                crate::SessionKeys {

1884

1

                    nimbus: alice_id_2.clone(),

1885

1

},

1886

1

                vec![]

1887

1

));

1888

1

            assert_ok!(Session::set_keys(

1889

1

                origin_of(BOB.into()),

1890

1

                crate::SessionKeys {

1891

1

                    nimbus: bob_id_2.clone(),

1892

1

},

1893

1

                vec![]

1894

1

));

1895

1896

1

            run_to_session(1u32);

1897

1

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

1898

1

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

1899

1

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

1900

1

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

1901

1902

1

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

1903

1

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

1904

1

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

1905

1

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

1906

1907

            // Everything should match to aura

1908

1

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

1909

//

1910

1911

1

            run_to_session(2u32);

1912

1

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

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

1

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

1920

1

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

1921

1

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

1922

1

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

1923

1924

            // Everything should match to aura

1925

1

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

1926

1

});

1927

1

1928

1929

#[test]

1930

1

fn test_session_keys_with_authority_assignment() {

1931

1

    ExtBuilder::default()

1932

1

        .with_balances(vec![

1933

1

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

1934

1

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

1935

1

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

1936

1

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

1937

1

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

1938

1

])

1939

1

        .with_empty_parachains(vec![1001, 1002])

1940

1

        .build()

1941

1

        .execute_with(|| {

1942

1

            run_to_block(2);

1943

1

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

1944

1

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

1945

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1946

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1947

1

1948

1

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

1949

1

            assert_eq!(

1950

1

                key_mapping_session_0.orchestrator_chain,

1951

1

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

1952

1

);

1953

1

            assert_eq!(

1954

1

                CollatorAssignment::collator_container_chain().orchestrator_chain,

1955

1

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

1956

1

);

1957

1958

1

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

1959

1

            assert_eq!(key_mapping_session_1, key_mapping_session_0,);

1960

1

            let old_assignment_session_1 =

1961

1

                CollatorAssignment::pending_collator_container_chain().unwrap();

1962

1

            assert_eq!(

1963

1

                old_assignment_session_1,

1964

1

                CollatorAssignment::collator_container_chain(),

1965

1

);

1966

1967

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2);

1968

1

            assert!(key_mapping_session_2.is_none());

1969

1970

            // Everything should match to aura

1971

1

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

1972

1973

            // Change Alice and Bob keys to something different

1974

            // for now lets change it to alice_2 and bob_2

1975

1

            assert_ok!(Session::set_keys(

1976

1

                origin_of(ALICE.into()),

1977

1

                crate::SessionKeys {

1978

1

                    nimbus: alice_id_2.clone(),

1979

1

},

1980

1

                vec![]

1981

1

));

1982

1

            assert_ok!(Session::set_keys(

1983

1

                origin_of(BOB.into()),

1984

1

                crate::SessionKeys {

1985

1

                    nimbus: bob_id_2.clone(),

1986

1

},

1987

1

                vec![]

1988

1

));

1989

1990

1

            run_to_session(1u32);

1991

1

            let old_key_mapping_session_1 = key_mapping_session_1;

1992

1

1993

1

            // Session 0 got removed

1994

1

            let key_mapping_session_0 = AuthorityAssignment::collator_container_chain(0);

1995

1

            assert!(key_mapping_session_0.is_none());

1996

1997

            // The values at session 1 did not change

1998

1

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

1999

1

            assert_eq!(key_mapping_session_1, old_key_mapping_session_1,);

2000

1

            assert_eq!(

2001

1

                CollatorAssignment::collator_container_chain(),

2002

1

                old_assignment_session_1,

2003

1

);

2004

2005

            // Session 2 uses the new keys

2006

1

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

2007

1

            assert_eq!(

2008

1

                key_mapping_session_2.orchestrator_chain,

2009

1

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

2010

1

);

2011

1

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

2012

2013

1

            let key_mapping_session_3 = AuthorityAssignment::collator_container_chain(3);

2014

1

            assert!(key_mapping_session_3.is_none());

2015

2016

            // Everything should match to aura

2017

1

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

2018

2019

1

            run_to_session(2u32);

2020

1

2021

1

            // Session 1 got removed

2022

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1);

2023

1

            assert!(key_mapping_session_1.is_none());

2024

2025

            // Session 2 uses the new keys

2026

1

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

2027

1

            assert_eq!(

2028

1

                key_mapping_session_2.orchestrator_chain,

2029

1

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

2030

1

);

2031

1

            assert_eq!(

2032

1

                old_assignment_session_1,

2033

1

                CollatorAssignment::collator_container_chain(),

2034

1

);

2035

2036

            // Session 3 uses the new keys

2037

1

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

2038

1

            assert_eq!(

2039

1

                key_mapping_session_3.orchestrator_chain,

2040

1

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

2041

1

);

2042

1

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

2043

2044

1

            let key_mapping_session_4 = AuthorityAssignment::collator_container_chain(4);

2045

1

            assert!(key_mapping_session_4.is_none());

2046

2047

            // Everything should match to aura

2048

1

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

2049

1

});

2050

1

2051

2052

2

fn call_transfer(

2053

2

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

2054

2

    value: u128,

2055

2

) -> RuntimeCall {

2056

2

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

2057

2

2058

2059

#[test]

2060

1

fn test_proxy_any() {

2061

1

    ExtBuilder::default()

2062

1

        .with_balances(vec![

2063

1

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

2064

1

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

2065

1

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

2066

1

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

2067

1

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

2068

1

])

2069

1

        .build()

2070

1

        .execute_with(|| {

2071

1

            run_to_block(2);

2072

1

2073

1

            let delay = 0;

2074

1

            assert_ok!(Proxy::add_proxy(

2075

1

                origin_of(ALICE.into()),

2076

1

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

2077

1

                ProxyType::Any,

2078

1

                delay

2079

1

));

2080

2081

1

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

2082

1

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

2083

1

            assert_ok!(Proxy::proxy(

2084

1

                origin_of(BOB.into()),

2085

1

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

2086

1

                None,

2087

1

                call

2088

1

));

2089

1

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

2090

1

2091

1

            assert_eq!(balance_after, balance_before + 200_000);

2092

1

});

2093

1

2094

2095

#[test]

2096

1

fn test_proxy_non_transfer() {

2097

1

    ExtBuilder::default()

2098

1

        .with_balances(vec![

2099

1

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

2100

1

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

2101

1

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

2102

1

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

2103

1

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

2104

1

])

2105

1

        .build()

2106

1

        .execute_with(|| {

2107

1

            run_to_block(2);

2108

1

2109

1

            let delay = 0;

2110

1

            assert_ok!(Proxy::add_proxy(

2111

1

                origin_of(ALICE.into()),

2112

1

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

2113

1

                ProxyType::NonTransfer,

2114

1

                delay

2115

1

));

2116

2117

1

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

2118

1

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

2119

1

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

2120

1

            assert_ok!(Proxy::proxy(

2121

1

                origin_of(BOB.into()),

2122

1

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

2123

1

                None,

2124

1

                call

2125

1

));

2126

1

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

2127

1

2128

1

            assert_eq!(balance_after, balance_before);

2129

1

});

2130

1

2131

2132

#[test]

2133

1

fn test_proxy_utility() {

2134

1

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

2135

1

    // subcalls don't allow to circumvent filters.

2136

1

2137

1

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

2138

1

    match ProxyType::Any {

2139

        ProxyType::Any

2140

        | ProxyType::NonTransfer

2141

        | ProxyType::Governance

2142

        | ProxyType::Staking

2143

        | ProxyType::CancelProxy

2144

        | ProxyType::Balances

2145

        | ProxyType::Registrar

2146

        | ProxyType::SudoRegistrar

2147

1

        | ProxyType::SessionKeyManagement => (),

2148

1

};

2149

1

2150

1

    // All except for any

2151

1

    let proxy_types = &[

2152

1

        ProxyType::NonTransfer,

2153

1

        ProxyType::Governance,

2154

1

        ProxyType::Staking,

2155

1

        ProxyType::CancelProxy,

2156

1

        ProxyType::Balances,

2157

1

        ProxyType::Registrar,

2158

1

        ProxyType::SudoRegistrar,

2159

1

        ProxyType::SessionKeyManagement,

2160

1

];

2161

2162

9

    for &proxy_type in proxy_types {

2163

8

        ExtBuilder::default()

2164

8

            .with_balances(vec![

2165

8

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

2166

8

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

2167

8

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

2168

8

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

2169

8

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

2170

8

])

2171

8

            .with_collators(vec![

2172

8

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

2173

8

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

2174

8

])

2175

8

            .with_sudo(AccountId::from(ALICE))

2176

8

            .build()

2177

8

            .execute_with(|| {

2178

8

                assert_ok!(Proxy::add_proxy(

2179

8

                    origin_of(ALICE.into()),

2180

8

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

2181

8

                    proxy_type,

2182

8

2183

8

));

2184

2185

8

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

2186

8

2187

8

                assert_ok!(Proxy::proxy(

2188

8

                    origin_of(BOB.into()),

2189

8

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

2190

8

                    None,

2191

8

                    Box::new(

2192

8

                        pallet_sudo::Call::sudo {

2193

8

                            call: Box::new(

2194

8

                                pallet_utility::Call::batch {

2195

8

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

2196

8

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

2197

8

                                        new_free: 42424242424242

2198

8

2199

8

                                    .into()]

2200

8

2201

8

                                .into()

2202

8

2203

8

2204

8

                        .into()

2205

8

2206

8

));

2207

2208

8

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

2209

8

});

2210

8

2211

1

2212

2213

#[test]

2214

1

fn check_well_known_keys() {

2215

    use frame_support::traits::PalletInfo;

2216

2217

    // Pallet is named "Paras" in Polkadot.

2218

1

    assert_eq!(

2219

1

        well_known_keys::PARAS_HEADS_INDEX,

2220

1

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

2221

1

);

2222

2223

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

2224

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

2225

1

    assert_eq!(

2226

1

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

2227

1

        Some("AuthorityAssignment")

2228

1

);

2229

1

    assert_eq!(

2230

1

        well_known_keys::AUTHORITY_ASSIGNMENT_PREFIX,

2231

1

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

2232

1

);

2233

2234

1

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

2235

1

    assert_eq!(

2236

1

        well_known_keys::SESSION_INDEX,

2237

1

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

2238

1

);

2239

1

2240

2241

#[test]

2242

1

fn test_staking_no_candidates_in_genesis() {

2243

1

    ExtBuilder::default()

2244

1

        .with_balances(vec![

2245

1

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

2246

1

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

2247

1

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

2248

1

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

2249

1

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

2250

1

])

2251

1

        .with_collators(vec![

2252

1

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

2253

1

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

2254

1

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

2255

1

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

2256

1

])

2257

1

        .with_empty_parachains(vec![1001, 1002])

2258

1

        .build()

2259

1

        .execute_with(|| {

2260

1

            run_to_block(2);

2261

1

2262

1

            let initial_candidates =

2263

1

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

2264

1

2265

1

            assert_eq!(initial_candidates, vec![]);

2266

1

});

2267

1

2268

2269

#[test]

2270

1

fn test_staking_join() {

2271

1

    ExtBuilder::default()

2272

1

        .with_balances(vec![

2273

1

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

2274

1

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

2275

1

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

2276

1

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

2277

1

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

2278

1

])

2279

1

        .with_collators(vec![

2280

1

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

2281

1

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

2282

1

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

2283

1

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

2284

1

])

2285

1

        .with_empty_parachains(vec![1001, 1002])

2286

1

        .build()

2287

1

        .execute_with(|| {

2288

1

            run_to_block(2);

2289

1

2290

1

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

2291

1

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

2292

1

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

2293

1

            assert_ok!(PooledStaking::request_delegate(

2294

1

                origin_of(ALICE.into()),

2295

1

                ALICE.into(),

2296

1

                TargetPool::AutoCompounding,

2297

1

                stake

2298

1

));

2299

2300

            // Immediately after joining, Alice is the top candidate

2301

1

            let eligible_candidates =

2302

1

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

2303

1

            assert_eq!(

2304

1

                eligible_candidates,

2305

1

                vec![EligibleCandidate {

2306

1

                    candidate: ALICE.into(),

2307

1

                    stake

2308

1

}]

2309

1

);

2310

2311

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

2312

1

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

2313

1

            assert_eq!(balance_before - balance_after, stake);

2314

1

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

2315

1

});

2316

1

2317

2318

#[test]

2319

1

fn test_staking_join_no_keys_registered() {

2320

1

    ExtBuilder::default()

2321

1

        .with_balances(vec![

2322

1

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

2323

1

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

2324

1

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

2325

1

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

2326

1

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

2327

1

])

2328

1

        .with_collators(vec![

2329

1

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

2330

1

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

2331

1

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

2332

1

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

2333

1

])

2334

1

        .with_empty_parachains(vec![

2335

1

            1001,

2336

1

            1002,

2337

1

])

2338

1

2339

1

        .build()

2340

1

        .execute_with(|| {

2341

1

            run_to_block(2);

2342

1

2343

1

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

2344

1

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

2345

1

            assert_ok!(Balances::transfer_allow_death(

2346

1

                origin_of(ALICE.into()),

2347

1

                new_account.clone().into(),

2348

1

                stake * 2

2349

1

));

2350

1

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

2351

1

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

2352

1

            assert_ok!(PooledStaking::request_delegate(

2353

1

                origin_of(new_account.clone()),

2354

1

                new_account.clone(),

2355

1

                TargetPool::AutoCompounding,

2356

1

                stake

2357

1

));

2358

2359

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

2360

            // pallet_session, so it is not eligible

2361

1

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

2362

1

            let eligible_candidates =

2363

1

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

2364

1

2365

1

            assert_eq!(eligible_candidates, vec![]);

2366

2367

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

2368

1

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

2369

1

            assert_eq!(balance_before - balance_after, stake);

2370

1

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

2371

1

});

2372

1

2373

2374

#[test]

2375

1

fn test_staking_register_keys_after_joining() {

2376

1

    ExtBuilder::default()

2377

1

        .with_balances(vec![

2378

1

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

2379

1

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

2380

1

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

2381

1

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

2382

1

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

2383

1

])

2384

1

        .with_collators(vec![

2385

1

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

2386

1

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

2387

1

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

2388

1

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

2389

1

])

2390

1

        .with_empty_parachains(vec![

2391

1

            1001,

2392

1

            1002,

2393

1

])

2394

1

2395

1

        .build()

2396

1

        .execute_with(|| {

2397

1

            run_to_block(2);

2398

1

2399

1

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

2400

1

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

2401

1

            assert_ok!(Balances::transfer_allow_death(

2402

1

                origin_of(ALICE.into()),

2403

1

                new_account.clone().into(),

2404

1

                stake * 2

2405

1

));

2406

1

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

2407

1

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

2408

1

            assert_ok!(PooledStaking::request_delegate(

2409

1

                origin_of(new_account.clone()),

2410

1

                new_account.clone(),

2411

1

                TargetPool::AutoCompounding,

2412

1

                stake

2413

1

));

2414

2415

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

2416

            // pallet_session, so it is not eligible

2417

1

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

2418

1

            let eligible_candidates =

2419

1

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

2420

1

            assert_eq!(eligible_candidates, vec![]);

2421

2422

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

2423

1

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

2424

1

            assert_eq!(balance_before - balance_after, stake);

2425

1

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

2426

2427

            // Now register the keys

2428

1

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

2429

1

            assert_ok!(Session::set_keys(

2430

1

                origin_of(new_account.clone()),

2431

1

                crate::SessionKeys {

2432

1

                    nimbus: new_account_id,

2433

1

},

2434

1

                vec![]

2435

1

));

2436

2437

            // Now eligible according to filter

2438

1

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

2439

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

2440

1

            let eligible_candidates =

2441

1

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

2442

1

            assert_eq!(eligible_candidates, vec![]);

2443

2444

            // Update candidate list

2445

1

            assert_ok!(PooledStaking::update_candidate_position(

2446

1

                origin_of(BOB.into()),

2447

1

                vec![new_account.clone()]

2448

1

));

2449

2450

            // Now it is eligible

2451

1

            let eligible_candidates =

2452

1

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

2453

1

            assert_eq!(

2454

1

                eligible_candidates,

2455

1

                vec![EligibleCandidate {

2456

1

                    candidate: new_account.clone(),

2457

1

                    stake

2458

1

}]

2459

1

);

2460

1

});

2461

1

2462

2463

#[test]

2464

1

fn test_staking_join_bad_origin() {

2465

1

    ExtBuilder::default()

2466

1

        .with_balances(vec![

2467

1

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

2468

1

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

2469

1

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

2470

1

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

2471

1

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

2472

1

])

2473

1

        .with_collators(vec![

2474

1

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

2475

1

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

2476

1

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

2477

1

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

2478

1

])

2479

1

        .with_empty_parachains(vec![1001, 1002])

2480

1

        .build()

2481

1

        .execute_with(|| {

2482

1

            run_to_block(2);

2483

1

2484

1

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

2485

1

            assert_noop!(

2486

1

                PooledStaking::request_delegate(

2487

1

                    root_origin(),

2488

1

                    ALICE.into(),

2489

1

                    TargetPool::AutoCompounding,

2490

1

                    stake

2491

1

),

2492

1

                BadOrigin,

2493

1

);

2494

1

});

2495

1

2496

2497

#[test]

2498

1

fn test_staking_join_below_self_delegation_min() {

2499

1

    ExtBuilder::default()

2500

1

        .with_balances(vec![

2501

1

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

2502

1

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

2503

1

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

2504

1

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

2505

1

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

2506

1

])

2507

1

        .with_collators(vec![

2508

1

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

2509

1

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

2510

1

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

2511

1

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

2512

1

])

2513

1

        .with_empty_parachains(vec![1001, 1002])

2514

1

        .build()

2515

1

        .execute_with(|| {

2516

1

            run_to_block(2);

2517

1

2518

1

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

2519

1

            assert_ok!(PooledStaking::request_delegate(

2520

1

                origin_of(ALICE.into()),

2521

1

                ALICE.into(),

2522

1

                TargetPool::AutoCompounding,

2523

1

                stake1

2524

1

));

2525

2526

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

2527

            // but the candidate is not eligible

2528

1

            let eligible_candidates =

2529

1

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

2530

1

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

2531

2532

1

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

2533

1

            assert_ok!(PooledStaking::request_delegate(

2534

1

                origin_of(ALICE.into()),

2535

1

                ALICE.into(),

2536

1

                TargetPool::AutoCompounding,

2537

1

                stake2,

2538

1

));

2539

2540

            // Still below, missing 1 unit

2541

1

            let eligible_candidates =

2542

1

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

2543

1

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

2544

2545

1

            let stake3 = 1;

2546

1

            assert_ok!(PooledStaking::request_delegate(

2547

1

                origin_of(ALICE.into()),

2548

1

                ALICE.into(),

2549

1

                TargetPool::AutoCompounding,

2550

1

                stake3,

2551

1

));

2552

2553

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

2554

1

            let eligible_candidates =

2555

1

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

2556

1

            assert_eq!(

2557

1

                eligible_candidates,

2558

1

                vec![EligibleCandidate {

2559

1

                    candidate: ALICE.into(),

2560

1

                    stake: stake1 + stake2 + stake3

2561

1

}],

2562

1

);

2563

1

});

2564

1

2565

2566

#[test]

2567

1

fn test_staking_join_no_self_delegation() {

2568

1

    ExtBuilder::default()

2569

1

        .with_balances(vec![

2570

1

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

2571

1

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

2572

1

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

2573

1

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

2574

1

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

2575

1

])

2576

1

        .with_collators(vec![

2577

1

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

2578

1

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

2579

1

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

2580

1

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

2581

1

])

2582

1

        .with_empty_parachains(vec![1001, 1002])

2583

1

        .build()

2584

1

        .execute_with(|| {

2585

1

            run_to_block(2);

2586

1

2587

1

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

2588

1

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

2589

1

            assert_ok!(PooledStaking::request_delegate(

2590

1

                origin_of(BOB.into()),

2591

1

                ALICE.into(),

2592

1

                TargetPool::AutoCompounding,

2593

1

                stake,

2594

1

));

2595

2596

1

            let eligible_candidates =

2597

1

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

2598

1

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

2599

1

});

2600

1

2601

2602

#[test]

2603

1

fn test_staking_join_before_self_delegation() {

2604

1

    ExtBuilder::default()

2605

1

        .with_balances(vec![

2606

1

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

2607

1

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

2608

1

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

2609

1

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

2610

1

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

2611

1

])

2612

1

        .with_collators(vec![

2613

1

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

2614

1

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

2615

1

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

2616

1

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

2617

1

])

2618

1

        .with_empty_parachains(vec![1001, 1002])

2619

1

        .build()

2620

1

        .execute_with(|| {

2621

1

            run_to_block(2);

2622

1

2623

1

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

2624

1

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

2625

1

            assert_ok!(PooledStaking::request_delegate(

2626

1

                origin_of(BOB.into()),

2627

1

                ALICE.into(),

2628

1

                TargetPool::AutoCompounding,

2629

1

                stake

2630

1

));

2631

2632

1

            let eligible_candidates =

2633

1

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

2634

1

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

2635

2636

1

            run_to_session(2);

2637

1

            assert_ok!(PooledStaking::execute_pending_operations(

2638

1

                origin_of(ALICE.into()),

2639

1

                vec![PendingOperationQuery {

2640

1

                    delegator: BOB.into(),

2641

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2642

1

                        candidate: ALICE.into(),

2643

1

                        at: 0,

2644

1

2645

1

}]

2646

1

            ),);

2647

2648

            // Now Alice joins with enough self-delegation

2649

1

            assert_ok!(PooledStaking::request_delegate(

2650

1

                origin_of(ALICE.into()),

2651

1

                ALICE.into(),

2652

1

                TargetPool::AutoCompounding,

2653

1

                stake

2654

1

));

2655

2656

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

2657

1

            let eligible_candidates =

2658

1

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

2659

1

            assert_eq!(

2660

1

                eligible_candidates,

2661

1

                vec![EligibleCandidate {

2662

1

                    candidate: ALICE.into(),

2663

1

                    stake: stake * 2,

2664

1

}],

2665

1

);

2666

1

});

2667

1

2668

2669

#[test]

2670

1

fn test_staking_join_twice_in_same_block() {

2671

1

    ExtBuilder::default()

2672

1

        .with_balances(vec![

2673

1

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

2674

1

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

2675

1

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

2676

1

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

2677

1

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

2678

1

])

2679

1

        .with_collators(vec![

2680

1

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

2681

1

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

2682

1

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

2683

1

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

2684

1

])

2685

1

        .with_empty_parachains(vec![1001, 1002])

2686

1

        .build()

2687

1

        .execute_with(|| {

2688

1

            run_to_block(2);

2689

1

2690

1

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

2691

1

            assert_ok!(PooledStaking::request_delegate(

2692

1

                origin_of(ALICE.into()),

2693

1

                ALICE.into(),

2694

1

                TargetPool::AutoCompounding,

2695

1

                stake1

2696

1

));

2697

2698

1

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

2699

1

            assert_ok!(PooledStaking::request_delegate(

2700

1

                origin_of(ALICE.into()),

2701

1

                ALICE.into(),

2702

1

                TargetPool::AutoCompounding,

2703

1

                stake2

2704

1

));

2705

2706

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

2707

1

            let eligible_candidates =

2708

1

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

2709

1

2710

1

            assert_eq!(

2711

1

                eligible_candidates,

2712

1

                vec![EligibleCandidate {

2713

1

                    candidate: ALICE.into(),

2714

1

                    stake: stake1 + stake2,

2715

1

}]

2716

1

);

2717

2718

1

            run_to_session(2);

2719

1

2720

1

            assert_ok!(PooledStaking::execute_pending_operations(

2721

1

                origin_of(ALICE.into()),

2722

1

                vec![PendingOperationQuery {

2723

1

                    delegator: ALICE.into(),

2724

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2725

1

                        candidate: ALICE.into(),

2726

1

                        at: 0,

2727

1

2728

1

}]

2729

1

            ),);

2730

2731

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

2732

1

});

2733

1

2734

2735

#[test]

2736

1

fn test_staking_join_execute_before_time() {

2737

1

    ExtBuilder::default()

2738

1

        .with_balances(vec![

2739

1

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

2740

1

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

2741

1

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

2742

1

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

2743

1

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

2744

1

])

2745

1

        .with_collators(vec![

2746

1

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

2747

1

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

2748

1

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

2749

1

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

2750

1

])

2751

1

        .with_empty_parachains(vec![1001, 1002])

2752

1

        .build()

2753

1

        .execute_with(|| {

2754

1

            run_to_block(2);

2755

1

2756

1

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

2757

1

            assert_ok!(PooledStaking::request_delegate(

2758

1

                origin_of(ALICE.into()),

2759

1

                ALICE.into(),

2760

1

                TargetPool::AutoCompounding,

2761

1

                stake

2762

1

));

2763

2764

            // Immediately after joining, Alice is the top candidate

2765

1

            let eligible_candidates =

2766

1

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

2767

1

            assert_eq!(

2768

1

                eligible_candidates,

2769

1

                vec![EligibleCandidate {

2770

1

                    candidate: ALICE.into(),

2771

1

                    stake

2772

1

}]

2773

1

);

2774

2775

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

2776

1

            let start_of_session_2 = session_to_block(2);

2777

1

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

2778

1

            run_to_block(start_of_session_2 - 2);

2779

1

            assert_noop!(

2780

1

                PooledStaking::execute_pending_operations(

2781

1

                    origin_of(ALICE.into()),

2782

1

                    vec![PendingOperationQuery {

2783

1

                        delegator: ALICE.into(),

2784

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

2785

1

                            candidate: ALICE.into(),

2786

1

                            at: 0,

2787

1

2788

1

}]

2789

1

),

2790

1

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

2791

1

);

2792

2793

1

            run_to_block(start_of_session_2);

2794

1

            assert_ok!(PooledStaking::execute_pending_operations(

2795

1

                origin_of(ALICE.into()),

2796

1

                vec![PendingOperationQuery {

2797

1

                    delegator: ALICE.into(),

2798

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2799

1

                        candidate: ALICE.into(),

2800

1

                        at: 0,

2801

1

2802

1

}]

2803

1

            ),);

2804

1

});

2805

1

2806

2807

#[test]

2808

1

fn test_staking_join_execute_any_origin() {

2809

1

    ExtBuilder::default()

2810

1

        .with_balances(vec![

2811

1

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

2812

1

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

2813

1

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

2814

1

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

2815

1

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

2816

1

])

2817

1

        .with_collators(vec![

2818

1

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

2819

1

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

2820

1

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

2821

1

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

2822

1

])

2823

1

        .with_empty_parachains(vec![1001, 1002])

2824

1

        .build()

2825

1

        .execute_with(|| {

2826

1

            run_to_block(2);

2827

1

2828

1

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

2829

1

            assert_ok!(PooledStaking::request_delegate(

2830

1

                origin_of(ALICE.into()),

2831

1

                ALICE.into(),

2832

1

                TargetPool::AutoCompounding,

2833

1

                stake

2834

1

));

2835

2836

            // Immediately after joining, Alice is the top candidate

2837

1

            let eligible_candidates =

2838

1

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

2839

1

            assert_eq!(

2840

1

                eligible_candidates,

2841

1

                vec![EligibleCandidate {

2842

1

                    candidate: ALICE.into(),

2843

1

                    stake

2844

1

}]

2845

1

);

2846

2847

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

2848

1

            run_to_session(2);

2849

1

            // Anyone can execute pending operations for anyone else

2850

1

            assert_ok!(PooledStaking::execute_pending_operations(

2851

1

                origin_of(BOB.into()),

2852

1

                vec![PendingOperationQuery {

2853

1

                    delegator: ALICE.into(),

2854

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2855

1

                        candidate: ALICE.into(),

2856

1

                        at: 0,

2857

1

2858

1

}]

2859

1

            ),);

2860

1

});

2861

1

2862

2863

#[test]

2864

1

fn test_staking_join_execute_bad_origin() {

2865

1

    ExtBuilder::default()

2866

1

        .with_balances(vec![

2867

1

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

2868

1

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

2869

1

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

2870

1

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

2871

1

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

2872

1

])

2873

1

        .with_collators(vec![

2874

1

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

2875

1

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

2876

1

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

2877

1

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

2878

1

])

2879

1

        .with_empty_parachains(vec![1001, 1002])

2880

1

        .build()

2881

1

        .execute_with(|| {

2882

1

            run_to_block(2);

2883

1

2884

1

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

2885

1

            assert_ok!(PooledStaking::request_delegate(

2886

1

                origin_of(ALICE.into()),

2887

1

                ALICE.into(),

2888

1

                TargetPool::AutoCompounding,

2889

1

                stake

2890

1

));

2891

2892

            // Immediately after joining, Alice is the top candidate

2893

1

            let eligible_candidates =

2894

1

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

2895

1

            assert_eq!(

2896

1

                eligible_candidates,

2897

1

                vec![EligibleCandidate {

2898

1

                    candidate: ALICE.into(),

2899

1

                    stake

2900

1

}]

2901

1

);

2902

2903

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

2904

1

            run_to_session(2);

2905

1

            assert_noop!(

2906

1

                PooledStaking::execute_pending_operations(

2907

1

                    root_origin(),

2908

1

                    vec![PendingOperationQuery {

2909

1

                        delegator: ALICE.into(),

2910

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

2911

1

                            candidate: ALICE.into(),

2912

1

                            at: 0,

2913

1

2914

1

}]

2915

1

),

2916

1

                BadOrigin,

2917

1

);

2918

1

});

2919

1

2920

2921

struct A {

2922

    delegator: AccountId,

2923

    candidate: AccountId,

2924

    target_pool: TargetPool,

2925

    stake: u128,

2926

2927

2928

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

2929

9

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

2930

9

    ExtBuilder::default()

2931

9

        .with_balances(vec![

2932

9

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

2933

9

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

2934

9

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

2935

9

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

2936

9

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

2937

9

])

2938

9

        .with_collators(vec![

2939

9

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

2940

9

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

2941

9

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

2942

9

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

2943

9

])

2944

9

        .with_empty_parachains(vec![1001, 1002])

2945

9

        .build()

2946

9

        .execute_with(|| {

2947

9

            run_to_block(2);

2948

2949

9

            for op in ops.iter() {

2950

9

                assert_ok!(PooledStaking::request_delegate(

2951

9

                    origin_of(op.delegator.clone()),

2952

9

                    op.candidate.clone(),

2953

9

                    op.target_pool,

2954

9

                    op.stake,

2955

9

));

2956

2957

2958

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

2959

9

            run_to_session(2);

2960

2961

9

            for op in ops.iter() {

2962

9

                let operation = match op.target_pool {

2963

9

                    TargetPool::AutoCompounding => PendingOperationKey::JoiningAutoCompounding {

2964

9

                        candidate: op.candidate.clone(),

2965

9

                        at: 0,

2966

9

},

2967

                    TargetPool::ManualRewards => PendingOperationKey::JoiningManualRewards {

2968

                        candidate: op.candidate.clone(),

2969

                        at: 0,

2970

},

2971

};

2972

2973

9

                assert_ok!(PooledStaking::execute_pending_operations(

2974

9

                    origin_of(op.delegator.clone()),

2975

9

                    vec![PendingOperationQuery {

2976

9

                        delegator: op.delegator.clone(),

2977

9

                        operation,

2978

9

}]

2979

9

));

2980

2981

2982

9

f()

2983

9

});

2984

9

2985

2986

#[test]

2987

1

fn test_staking_leave_exact_amount() {

2988

1

    setup_staking_join_and_execute(

2989

1

        vec![A {

2990

1

            delegator: ALICE.into(),

2991

1

            candidate: ALICE.into(),

2992

1

            target_pool: TargetPool::AutoCompounding,

2993

1

            stake: 10 * MinimumSelfDelegation::get(),

2994

1

}],

2995

1

        || {

2996

1

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

2997

1

            assert_ok!(PooledStaking::request_undelegate(

2998

1

                origin_of(ALICE.into()),

2999

1

                ALICE.into(),

3000

1

                TargetPool::AutoCompounding,

3001

1

                SharesOrStake::Stake(stake),

3002

1

));

3003

3004

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

3005

1

            let eligible_candidates =

3006

1

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

3007

1

            assert_eq!(eligible_candidates, vec![]);

3008

1

},

3009

1

3010

1

3011

3012

#[test]

3013

1

fn test_staking_leave_bad_origin() {

3014

1

    setup_staking_join_and_execute(

3015

1

        vec![A {

3016

1

            delegator: ALICE.into(),

3017

1

            candidate: ALICE.into(),

3018

1

            target_pool: TargetPool::AutoCompounding,

3019

1

            stake: 10 * MinimumSelfDelegation::get(),

3020

1

}],

3021

1

        || {

3022

1

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

3023

1

            assert_noop!(

3024

1

                PooledStaking::request_undelegate(

3025

1

                    root_origin(),

3026

1

                    ALICE.into(),

3027

1

                    TargetPool::AutoCompounding,

3028

1

                    SharesOrStake::Stake(stake),

3029

1

),

3030

1

                BadOrigin

3031

1

);

3032

1

},

3033

1

3034

1

3035

3036

#[test]

3037

1

fn test_staking_leave_more_than_allowed() {

3038

1

    setup_staking_join_and_execute(

3039

1

        vec![A {

3040

1

            delegator: ALICE.into(),

3041

1

            candidate: ALICE.into(),

3042

1

            target_pool: TargetPool::AutoCompounding,

3043

1

            stake: 10 * MinimumSelfDelegation::get(),

3044

1

}],

3045

1

        || {

3046

1

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

3047

1

            assert_noop!(

3048

1

                PooledStaking::request_undelegate(

3049

1

                    origin_of(ALICE.into()),

3050

1

                    ALICE.into(),

3051

1

                    TargetPool::AutoCompounding,

3052

1

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

3053

1

),

3054

1

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

3055

1

);

3056

1

},

3057

1

);

3058

1

3059

3060

#[test]

3061

1

fn test_staking_leave_in_separate_transactions() {

3062

1

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

3063

1

3064

1

    setup_staking_join_and_execute(

3065

1

        vec![A {

3066

1

            delegator: ALICE.into(),

3067

1

            candidate: ALICE.into(),

3068

1

            target_pool: TargetPool::AutoCompounding,

3069

1

            stake,

3070

1

}],

3071

1

        || {

3072

1

            let half_stake = stake / 2;

3073

1

            assert_ok!(PooledStaking::request_undelegate(

3074

1

                origin_of(ALICE.into()),

3075

1

                ALICE.into(),

3076

1

                TargetPool::AutoCompounding,

3077

1

                SharesOrStake::Stake(half_stake),

3078

1

));

3079

3080

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

3081

1

            let eligible_candidates =

3082

1

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

3083

1

            let remaining_stake = stake - half_stake;

3084

1

            assert_eq!(

3085

1

                eligible_candidates,

3086

1

                vec![EligibleCandidate {

3087

1

                    candidate: ALICE.into(),

3088

1

                    stake: remaining_stake,

3089

1

}],

3090

1

);

3091

3092

1

            assert_ok!(PooledStaking::request_undelegate(

3093

1

                origin_of(ALICE.into()),

3094

1

                ALICE.into(),

3095

1

                TargetPool::AutoCompounding,

3096

1

                SharesOrStake::Stake(remaining_stake),

3097

1

));

3098

3099

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

3100

1

            let eligible_candidates =

3101

1

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

3102

1

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

3103

1

},

3104

1

);

3105

1

3106

3107

#[test]

3108

1

fn test_staking_leave_all_except_some_dust() {

3109

1

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

3110

1

3111

1

    setup_staking_join_and_execute(

3112

1

        vec![A {

3113

1

            delegator: ALICE.into(),

3114

1

            candidate: ALICE.into(),

3115

1

            target_pool: TargetPool::AutoCompounding,

3116

1

            stake,

3117

1

}],

3118

1

        || {

3119

1

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

3120

1

            assert_ok!(PooledStaking::request_undelegate(

3121

1

                origin_of(ALICE.into()),

3122

1

                ALICE.into(),

3123

1

                TargetPool::AutoCompounding,

3124

1

                SharesOrStake::Stake(stake - dust),

3125

1

));

3126

3127

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

3128

1

            assert_eq!(

3129

1

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

3130

1

                    AccountId::from(ALICE),

3131

1

                    PoolsKey::CandidateTotalStake

3132

1

),

3133

1

                dust,

3134

1

);

3135

3136

1

            let eligible_candidates =

3137

1

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

3138

1

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

3139

3140

            // Leave with remaining stake

3141

1

            assert_ok!(PooledStaking::request_undelegate(

3142

1

                origin_of(ALICE.into()),

3143

1

                ALICE.into(),

3144

1

                TargetPool::AutoCompounding,

3145

1

                SharesOrStake::Stake(dust),

3146

1

));

3147

3148

            // Alice has no more stake left

3149

1

            assert_eq!(

3150

1

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

3151

1

                    AccountId::from(ALICE),

3152

1

                    PoolsKey::CandidateTotalStake

3153

1

),

3154

1

0,

3155

1

);

3156

1

},

3157

1

);

3158

1

3159

3160

#[test]

3161

1

fn test_staking_leave_execute_before_time() {

3162

1

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

3163

1

3164

1

    setup_staking_join_and_execute(

3165

1

        vec![A {

3166

1

            delegator: ALICE.into(),

3167

1

            candidate: ALICE.into(),

3168

1

            target_pool: TargetPool::AutoCompounding,

3169

1

            stake,

3170

1

}],

3171

1

        || {

3172

1

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

3173

1

            let at = Session::current_index();

3174

1

            assert_ok!(PooledStaking::request_undelegate(

3175

1

                origin_of(ALICE.into()),

3176

1

                ALICE.into(),

3177

1

                TargetPool::AutoCompounding,

3178

1

                SharesOrStake::Stake(stake),

3179

1

));

3180

3181

            // Request undelegate does not change account balance

3182

1

            assert_eq!(

3183

1

                balance_before,

3184

1

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

3185

1

);

3186

3187

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

3188

1

            let start_of_session_4 = session_to_block(4);

3189

1

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

3190

1

            run_to_block(start_of_session_4 - 2);

3191

1

3192

1

            assert_noop!(

3193

1

                PooledStaking::execute_pending_operations(

3194

1

                    origin_of(ALICE.into()),

3195

1

                    vec![PendingOperationQuery {

3196

1

                        delegator: ALICE.into(),

3197

1

                        operation: PendingOperationKey::Leaving {

3198

1

                            candidate: ALICE.into(),

3199

1

at,

3200

1

3201

1

}]

3202

1

),

3203

1

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

3204

1

);

3205

1

},

3206

1

);

3207

1

3208

3209

#[test]

3210

1

fn test_staking_leave_execute_any_origin() {

3211

1

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

3212

1

3213

1

    setup_staking_join_and_execute(

3214

1

        vec![A {

3215

1

            delegator: ALICE.into(),

3216

1

            candidate: ALICE.into(),

3217

1

            target_pool: TargetPool::AutoCompounding,

3218

1

            stake,

3219

1

}],

3220

1

        || {

3221

1

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

3222

1

            let at = Session::current_index();

3223

1

            assert_ok!(PooledStaking::request_undelegate(

3224

1

                origin_of(ALICE.into()),

3225

1

                ALICE.into(),

3226

1

                TargetPool::AutoCompounding,

3227

1

                SharesOrStake::Stake(stake),

3228

1

));

3229

3230

            // Request undelegate does not change account balance

3231

1

            assert_eq!(

3232

1

                balance_before,

3233

1

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

3234

1

);

3235

3236

1

            run_to_session(4);

3237

1

3238

1

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

3239

1

3240

1

            assert_ok!(PooledStaking::execute_pending_operations(

3241

1

                // Any signed origin can execute this, the stake will go to Alice account

3242

1

                origin_of(BOB.into()),

3243

1

                vec![PendingOperationQuery {

3244

1

                    delegator: ALICE.into(),

3245

1

                    operation: PendingOperationKey::Leaving {

3246

1

                        candidate: ALICE.into(),

3247

1

at,

3248

1

3249

1

}]

3250

1

            ),);

3251

3252

1

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

3253

1

            assert_eq!(balance_after - balance_before, stake);

3254

1

},

3255

1

);

3256

1

3257

3258

#[test]

3259

1

fn test_staking_leave_execute_bad_origin() {

3260

1

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

3261

1

3262

1

    setup_staking_join_and_execute(

3263

1

        vec![A {

3264

1

            delegator: ALICE.into(),

3265

1

            candidate: ALICE.into(),

3266

1

            target_pool: TargetPool::AutoCompounding,

3267

1

            stake,

3268

1

}],

3269

1

        || {

3270

1

            let at = Session::current_index();

3271

1

            assert_ok!(PooledStaking::request_undelegate(

3272

1

                origin_of(ALICE.into()),

3273

1

                ALICE.into(),

3274

1

                TargetPool::AutoCompounding,

3275

1

                SharesOrStake::Stake(stake),

3276

1

));

3277

3278

1

            run_to_session(4);

3279

1

3280

1

            assert_noop!(

3281

1

                PooledStaking::execute_pending_operations(

3282

1

                    root_origin(),

3283

1

                    vec![PendingOperationQuery {

3284

1

                        delegator: ALICE.into(),

3285

1

                        operation: PendingOperationKey::Leaving {

3286

1

                            candidate: ALICE.into(),

3287

1

at,

3288

1

3289

1

}]

3290

1

),

3291

1

                BadOrigin

3292

1

);

3293

1

},

3294

1

);

3295

1

3296

3297

#[test]

3298

1

fn test_staking_swap() {

3299

1

    setup_staking_join_and_execute(

3300

1

        vec![A {

3301

1

            delegator: ALICE.into(),

3302

1

            candidate: ALICE.into(),

3303

1

            target_pool: TargetPool::AutoCompounding,

3304

1

            stake: 10 * MinimumSelfDelegation::get(),

3305

1

}],

3306

1

        || {

3307

1

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

3308

1

            assert_ok!(PooledStaking::swap_pool(

3309

1

                origin_of(ALICE.into()),

3310

1

                ALICE.into(),

3311

1

                TargetPool::AutoCompounding,

3312

1

                SharesOrStake::Stake(stake),

3313

1

));

3314

3315

1

            assert_eq!(

3316

1

                PooledStaking::computed_stake(

3317

1

                    ALICE.into(),

3318

1

                    ALICE.into(),

3319

1

                    AllTargetPool::AutoCompounding

3320

1

),

3321

1

                Some(0u32.into())

3322

1

);

3323

1

            assert_eq!(

3324

1

                PooledStaking::computed_stake(

3325

1

                    ALICE.into(),

3326

1

                    ALICE.into(),

3327

1

                    AllTargetPool::ManualRewards

3328

1

),

3329

1

                Some(stake)

3330

1

);

3331

3332

1

            assert_ok!(PooledStaking::swap_pool(

3333

1

                origin_of(ALICE.into()),

3334

1

                ALICE.into(),

3335

1

                TargetPool::ManualRewards,

3336

1

                SharesOrStake::Stake(stake),

3337

1

));

3338

3339

1

            assert_eq!(

3340

1

                PooledStaking::computed_stake(

3341

1

                    ALICE.into(),

3342

1

                    ALICE.into(),

3343

1

                    AllTargetPool::AutoCompounding

3344

1

),

3345

1

                Some(stake)

3346

1

);

3347

1

            assert_eq!(

3348

1

                PooledStaking::computed_stake(

3349

1

                    ALICE.into(),

3350

1

                    ALICE.into(),

3351

1

                    AllTargetPool::ManualRewards

3352

1

),

3353

1

                Some(0u32.into())

3354

1

);

3355

1

},

3356

1

3357

1

3358

3359

#[test]

3360

1

fn test_pallet_session_takes_validators_from_invulnerables_and_staking() {

3361

1

    // Alice, Bob, Charlie are invulnerables

3362

1

    // Alice, Dave are in pallet_staking

3363

1

    // Expected collators are Alice, Bob, Charlie, Dave

3364

1

    ExtBuilder::default()

3365

1

        .with_balances(vec![

3366

1

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

3367

1

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

3368

1

            (AccountId::from(BOB), 100_000 * UNIT),

3369

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3370

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3371

1

])

3372

1

        .with_collators(vec![

3373

1

            (AccountId::from(ALICE), 210 * UNIT),

3374

1

            (AccountId::from(BOB), 100 * UNIT),

3375

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3376

1

])

3377

1

        .with_empty_parachains(vec![1001, 1002])

3378

1

        .build()

3379

1

        .execute_with(|| {

3380

1

            run_to_block(2);

3381

1

3382

1

            let stake = 10 * MinimumSelfDelegation::get();

3383

1

3384

1

            assert_ok!(PooledStaking::request_delegate(

3385

1

                origin_of(ALICE.into()),

3386

1

                ALICE.into(),

3387

1

                TargetPool::AutoCompounding,

3388

1

                stake,

3389

1

));

3390

3391

            // Register Dave in pallet_session (invulnerables are automatically registered)

3392

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3393

1

            assert_ok!(Session::set_keys(

3394

1

                origin_of(DAVE.into()),

3395

1

                crate::SessionKeys {

3396

1

                    nimbus: dave_account_id,

3397

1

},

3398

1

                vec![]

3399

1

));

3400

3401

1

            assert_ok!(PooledStaking::request_delegate(

3402

1

                origin_of(DAVE.into()),

3403

1

                DAVE.into(),

3404

1

                TargetPool::AutoCompounding,

3405

1

                stake,

3406

1

));

3407

3408

1

            let eligible_candidates =

3409

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3410

1

            assert_eq!(

3411

1

                eligible_candidates,

3412

1

                vec![

3413

1

                    EligibleCandidate {

3414

1

                        candidate: ALICE.into(),

3415

1

                        stake

3416

1

},

3417

1

                    EligibleCandidate {

3418

1

                        candidate: DAVE.into(),

3419

1

                        stake

3420

1

},

3421

1

3422

1

);

3423

3424

1

            assert_eq!(

3425

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3426

1

                vec![

3427

1

                    AccountId::from(ALICE),

3428

1

                    AccountId::from(BOB),

3429

1

                    AccountId::from(CHARLIE),

3430

1

3431

1

);

3432

3433

            // Need to trigger new session to update pallet_session

3434

1

            run_to_session(2);

3435

1

3436

1

            assert_eq!(

3437

1

                Session::validators(),

3438

1

                vec![

3439

1

                    AccountId::from(ALICE),

3440

1

                    AccountId::from(BOB),

3441

1

                    AccountId::from(CHARLIE),

3442

1

                    AccountId::from(DAVE),

3443

1

3444

1

);

3445

1

});

3446

1

3447

3448

#[test]

3449

1

fn test_pallet_session_limits_num_validators() {

3450

1

    // Set max_collators = 2, now only the first 2 invulnerables are valid collators

3451

1

    ExtBuilder::default()

3452

1

        .with_balances(vec![

3453

1

            // Alice gets 10k extra tokens for her mapping deposit

3454

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3455

1

            (AccountId::from(BOB), 100_000 * UNIT),

3456

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3457

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3458

1

])

3459

1

        .with_collators(vec![

3460

1

            (AccountId::from(ALICE), 210 * UNIT),

3461

1

            (AccountId::from(BOB), 100 * UNIT),

3462

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3463

1

])

3464

1

        .with_empty_parachains(vec![1001, 1002])

3465

1

        .with_config(pallet_configuration::HostConfiguration {

3466

1

            max_collators: 2,

3467

1

            min_orchestrator_collators: 2,

3468

1

            max_orchestrator_collators: 2,

3469

1

            collators_per_container: 2,

3470

1

            full_rotation_period: 24,

3471

1

            ..Default::default()

3472

1

})

3473

1

        .build()

3474

1

        .execute_with(|| {

3475

1

            run_to_block(2);

3476

1

3477

1

            let stake = 10 * MinimumSelfDelegation::get();

3478

1

3479

1

            assert_ok!(PooledStaking::request_delegate(

3480

1

                origin_of(ALICE.into()),

3481

1

                ALICE.into(),

3482

1

                TargetPool::AutoCompounding,

3483

1

                stake,

3484

1

));

3485

3486

            // Register Dave in pallet_session (invulnerables are automatically registered)

3487

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3488

1

            assert_ok!(Session::set_keys(

3489

1

                origin_of(DAVE.into()),

3490

1

                crate::SessionKeys {

3491

1

                    nimbus: dave_account_id,

3492

1

},

3493

1

                vec![]

3494

1

));

3495

3496

1

            assert_ok!(PooledStaking::request_delegate(

3497

1

                origin_of(DAVE.into()),

3498

1

                DAVE.into(),

3499

1

                TargetPool::AutoCompounding,

3500

1

                stake,

3501

1

));

3502

3503

1

            let eligible_candidates =

3504

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3505

1

            assert_eq!(

3506

1

                eligible_candidates,

3507

1

                vec![

3508

1

                    EligibleCandidate {

3509

1

                        candidate: ALICE.into(),

3510

1

                        stake

3511

1

},

3512

1

                    EligibleCandidate {

3513

1

                        candidate: DAVE.into(),

3514

1

                        stake

3515

1

},

3516

1

3517

1

);

3518

3519

1

            assert_eq!(

3520

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3521

1

                vec![

3522

1

                    AccountId::from(ALICE),

3523

1

                    AccountId::from(BOB),

3524

1

                    AccountId::from(CHARLIE),

3525

1

3526

1

);

3527

3528

            // Need to trigger new session to update pallet_session

3529

1

            run_to_session(2);

3530

1

3531

1

            assert_eq!(

3532

1

                Session::validators(),

3533

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3534

1

);

3535

1

});

3536

1

3537

3538

#[test]

3539

1

fn test_pallet_session_limits_num_validators_from_staking() {

3540

1

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

3541

1

    ExtBuilder::default()

3542

1

        .with_balances(vec![

3543

1

            // Alice gets 10k extra tokens for her mapping deposit

3544

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3545

1

            (AccountId::from(BOB), 100_000 * UNIT),

3546

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3547

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3548

1

])

3549

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3550

1

        .with_empty_parachains(vec![1001, 1002])

3551

1

        .with_config(pallet_configuration::HostConfiguration {

3552

1

            max_collators: 2,

3553

1

            min_orchestrator_collators: 2,

3554

1

            max_orchestrator_collators: 2,

3555

1

            collators_per_container: 2,

3556

1

            full_rotation_period: 24,

3557

1

            ..Default::default()

3558

1

})

3559

1

        .build()

3560

1

        .execute_with(|| {

3561

1

            run_to_block(2);

3562

1

3563

1

            let stake = 10 * MinimumSelfDelegation::get();

3564

1

3565

1

            // Register accounts in pallet_session (invulnerables are automatically registered)

3566

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3567

1

            assert_ok!(Session::set_keys(

3568

1

                origin_of(BOB.into()),

3569

1

                crate::SessionKeys {

3570

1

                    nimbus: bob_account_id,

3571

1

},

3572

1

                vec![]

3573

1

));

3574

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

3575

1

            assert_ok!(Session::set_keys(

3576

1

                origin_of(CHARLIE.into()),

3577

1

                crate::SessionKeys {

3578

1

                    nimbus: charlie_account_id,

3579

1

},

3580

1

                vec![]

3581

1

));

3582

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3583

1

            assert_ok!(Session::set_keys(

3584

1

                origin_of(DAVE.into()),

3585

1

                crate::SessionKeys {

3586

1

                    nimbus: dave_account_id,

3587

1

},

3588

1

                vec![]

3589

1

));

3590

3591

1

            assert_ok!(PooledStaking::request_delegate(

3592

1

                origin_of(BOB.into()),

3593

1

                BOB.into(),

3594

1

                TargetPool::AutoCompounding,

3595

1

                stake,

3596

1

));

3597

3598

1

            assert_ok!(PooledStaking::request_delegate(

3599

1

                origin_of(CHARLIE.into()),

3600

1

                CHARLIE.into(),

3601

1

                TargetPool::AutoCompounding,

3602

1

                stake,

3603

1

));

3604

3605

1

            assert_ok!(PooledStaking::request_delegate(

3606

1

                origin_of(DAVE.into()),

3607

1

                DAVE.into(),

3608

1

                TargetPool::AutoCompounding,

3609

1

                stake,

3610

1

));

3611

3612

1

            let eligible_candidates =

3613

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3614

1

            assert_eq!(

3615

1

                eligible_candidates,

3616

1

                vec![

3617

1

                    EligibleCandidate {

3618

1

                        candidate: BOB.into(),

3619

1

                        stake

3620

1

},

3621

1

                    EligibleCandidate {

3622

1

                        candidate: CHARLIE.into(),

3623

1

                        stake

3624

1

},

3625

1

                    EligibleCandidate {

3626

1

                        candidate: DAVE.into(),

3627

1

                        stake

3628

1

},

3629

1

3630

1

);

3631

3632

1

            assert_eq!(

3633

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3634

1

                vec![AccountId::from(ALICE),]

3635

1

);

3636

3637

            // Need to trigger new session to update pallet_session

3638

1

            run_to_session(2);

3639

1

3640

1

            assert_eq!(

3641

1

                Session::validators(),

3642

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3643

1

);

3644

1

});

3645

1

3646

3647

#[test]

3648

1

fn test_reward_to_staking_candidate() {

3649

1

    // Alice, Bob, Charlie are invulnerables

3650

1

    ExtBuilder::default()

3651

1

        .with_balances(vec![

3652

1

            // Alice gets 10k extra tokens for her mapping deposit

3653

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3654

1

            (AccountId::from(BOB), 100_000 * UNIT),

3655

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3656

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3657

1

])

3658

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3659

1

        .with_empty_parachains(vec![1001, 1002])

3660

1

        .build()

3661

1

        .execute_with(|| {

3662

1

            run_to_block(2);

3663

1

3664

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3665

1

            assert_ok!(Session::set_keys(

3666

1

                origin_of(DAVE.into()),

3667

1

                crate::SessionKeys {

3668

1

                    nimbus: dave_account_id,

3669

1

},

3670

1

                vec![]

3671

1

));

3672

3673

            // We make delegations to DAVE so that she is an elligible candidate.

3674

3675

1

            let stake = 10 * MinimumSelfDelegation::get();

3676

1

3677

1

            assert_ok!(PooledStaking::request_delegate(

3678

1

                origin_of(DAVE.into()),

3679

1

                DAVE.into(),

3680

1

                TargetPool::ManualRewards,

3681

1

                stake,

3682

1

));

3683

1

            assert_ok!(PooledStaking::request_delegate(

3684

1

                origin_of(BOB.into()),

3685

1

                DAVE.into(),

3686

1

                TargetPool::AutoCompounding,

3687

1

                stake,

3688

1

));

3689

3690

            // wait few sessions for the request to be executable

3691

1

            run_to_session(3u32);

3692

1

            assert_ok!(PooledStaking::execute_pending_operations(

3693

1

                origin_of(ALICE.into()),

3694

1

                vec![

3695

1

                    PendingOperationQuery {

3696

1

                        delegator: DAVE.into(),

3697

1

                        operation: PendingOperationKey::JoiningManualRewards {

3698

1

                            candidate: DAVE.into(),

3699

1

                            at: 0

3700

1

3701

1

},

3702

1

                    PendingOperationQuery {

3703

1

                        delegator: BOB.into(),

3704

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3705

1

                            candidate: DAVE.into(),

3706

1

                            at: 0

3707

1

3708

1

3709

1

3710

1

));

3711

3712

            // wait for next session so that DAVE is elected

3713

1

            run_to_session(4u32);

3714

1

3715

1

            assert_eq!(

3716

1

                Session::validators(),

3717

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

3718

1

);

3719

3720

1

            let account: AccountId = DAVE.into();

3721

1

            let balance_before = System::account(account.clone()).data.free;

3722

1

            let summary = (0..100)

3723

1

                .find_map(|_| {

3724

1

                    let summary = run_block();

3725

1

                    if summary.author_id == DAVE.into() {

3726

1

                        Some(summary)

3727

                    } else {

3728

                        None

3729

3730

1

})

3731

1

                .unwrap_or_else(|| panic!("DAVE doesn't seem to author any blocks"));

3732

1

            let balance_after = System::account(account).data.free;

3733

1

3734

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3735

1

            // rewards are shared between orchestrator and registered paras

3736

1

            let orchestrator_rewards = all_rewards / 3;

3737

1

            let candidate_rewards = RewardsCollatorCommission::get() * orchestrator_rewards;

3738

1

3739

1

            assert_eq!(

3740

1

                candidate_rewards,

3741

1

                balance_after - balance_before,

3742

                "dave should get the correct reward portion"

3743

);

3744

1

});

3745

1

3746

3747

#[test]

3748

1

fn test_reward_to_invulnerable() {

3749

1

    // Alice, Bob, Charlie are invulnerables

3750

1

    ExtBuilder::default()

3751

1

        .with_balances(vec![

3752

1

            // Alice gets 10k extra tokens for her mapping deposit

3753

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3754

1

            (AccountId::from(BOB), 100_000 * UNIT),

3755

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3756

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3757

1

])

3758

1

        .with_collators(vec![

3759

1

            (AccountId::from(ALICE), 210 * UNIT),

3760

1

            (AccountId::from(BOB), 100 * UNIT),

3761

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3762

1

])

3763

1

        .with_empty_parachains(vec![1001, 1002])

3764

1

        .build()

3765

1

        .execute_with(|| {

3766

1

            run_to_block(2);

3767

1

3768

1

            // We make delegations to ALICE so that she is an elligible candidate.

3769

1

            // However since she is an invulnerable she should get all the

3770

1

            // rewards.

3771

1

3772

1

            let stake = 10 * MinimumSelfDelegation::get();

3773

1

3774

1

            assert_ok!(PooledStaking::request_delegate(

3775

1

                origin_of(ALICE.into()),

3776

1

                ALICE.into(),

3777

1

                TargetPool::ManualRewards,

3778

1

                stake,

3779

1

));

3780

1

            assert_ok!(PooledStaking::request_delegate(

3781

1

                origin_of(BOB.into()),

3782

1

                ALICE.into(),

3783

1

                TargetPool::AutoCompounding,

3784

1

                stake,

3785

1

));

3786

3787

            // wait few sessions for the request to be executable

3788

1

            run_to_session(3u32);

3789

1

            assert_ok!(PooledStaking::execute_pending_operations(

3790

1

                origin_of(ALICE.into()),

3791

1

                vec![

3792

1

                    PendingOperationQuery {

3793

1

                        delegator: ALICE.into(),

3794

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3795

1

                            candidate: ALICE.into(),

3796

1

                            at: 0

3797

1

3798

1

},

3799

1

                    PendingOperationQuery {

3800

1

                        delegator: BOB.into(),

3801

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3802

1

                            candidate: ALICE.into(),

3803

1

                            at: 0

3804

1

3805

1

3806

1

3807

1

));

3808

3809

            // wait for next session so that ALICE is elected

3810

1

            run_to_session(4u32);

3811

1

3812

1

            let account: AccountId = ALICE.into();

3813

1

            let balance_before = System::account(account.clone()).data.free;

3814

1

3815

1

            let summary = (0..100)

3816

2

                .find_map(|_| {

3817

2

                    let summary = run_block();

3818

2

                    if summary.author_id == ALICE.into() {

3819

1

                        Some(summary)

3820

                    } else {

3821

1

                        None

3822

3823

2

})

3824

1

                .unwrap_or_else(|| panic!("ALICE doesn't seem to author any blocks"));

3825

1

3826

1

            let balance_after = System::account(account).data.free;

3827

1

3828

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3829

1

            // rewards are shared between orchestrator and registered paras

3830

1

            let orchestrator_rewards = all_rewards / 3;

3831

1

            assert_eq!(

3832

1

                orchestrator_rewards,

3833

1

                balance_after - balance_before,

3834

                "alice should get the correct reward portion"

3835

);

3836

1

});

3837

1

3838

3839

#[test]

3840

1

fn test_reward_to_invulnerable_with_key_change() {

3841

1

    ExtBuilder::default()

3842

1

        .with_balances(vec![

3843

1

            // Alice gets 10k extra tokens for her mapping deposit

3844

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3845

1

            (AccountId::from(BOB), 100_000 * UNIT),

3846

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3847

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3848

1

])

3849

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3850

1

        .with_empty_parachains(vec![1001, 1002])

3851

1

        .build()

3852

1

        .execute_with(|| {

3853

1

            run_to_block(2);

3854

1

3855

1

            run_to_session(2u32);

3856

1

3857

1

            // change key, this should be reflected 2 sessions afterward

3858

1

            let alice_new_key = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3859

1

            assert_ok!(Session::set_keys(

3860

1

                origin_of(ALICE.into()),

3861

1

                crate::SessionKeys {

3862

1

                    nimbus: alice_new_key,

3863

1

},

3864

1

                vec![]

3865

1

));

3866

3867

1

            run_to_session(4u32);

3868

1

3869

1

            let account: AccountId = ALICE.into();

3870

1

            let balance_before = System::account(account.clone()).data.free;

3871

1

3872

1

            let summary = run_block();

3873

1

            assert_eq!(summary.author_id, ALICE.into());

3874

3875

1

            let balance_after = System::account(account).data.free;

3876

1

3877

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3878

1

            // rewards are shared between orchestrator and registered paras

3879

1

            let orchestrator_rewards = all_rewards / 3;

3880

1

            assert_eq!(

3881

1

                orchestrator_rewards,

3882

1

                balance_after - balance_before,

3883

                "alice should get the correct reward portion"

3884

);

3885

1

});

3886

1

3887

3888

#[test]

3889

1

fn test_migration_config_add_full_rotation_mode() {

3890

1

    ExtBuilder::default().build().execute_with(|| {

3891

        const CONFIGURATION_ACTIVE_CONFIG_KEY: &[u8] =

3892

            &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385");

3893

        const CONFIGURATION_PENDING_CONFIGS_KEY: &[u8] =

3894

            &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22d53b4123b2e186e07fb7bad5dda5f55c0");

3895

3896

        // Modify active config

3897

1

        frame_support::storage::unhashed::put_raw(

3898

1

            CONFIGURATION_ACTIVE_CONFIG_KEY,

3899

1

            &HostConfigurationV3 {

3900

1

                max_collators: 5,

3901

1

                min_orchestrator_collators: 2,

3902

1

                max_orchestrator_collators: 1,

3903

1

                collators_per_container: 3,

3904

1

                full_rotation_period: 4,

3905

1

                collators_per_parathread: 2,

3906

1

                parathreads_per_collator: 1,

3907

1

                target_container_chain_fullness: Perbill::from_percent(45),

3908

1

                max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3909

1

3910

1

            .encode(),

3911

1

);

3912

1

        // Modify pending configs

3913

1

        frame_support::storage::unhashed::put_raw(

3914

1

            CONFIGURATION_PENDING_CONFIGS_KEY,

3915

1

            &vec![

3916

1

3917

1

                    1234u32,

3918

1

                    HostConfigurationV3 {

3919

1

                        max_collators: 1,

3920

1

                        min_orchestrator_collators: 4,

3921

1

                        max_orchestrator_collators: 45,

3922

1

                        collators_per_container: 5,

3923

1

                        full_rotation_period: 1,

3924

1

                        collators_per_parathread: 1,

3925

1

                        parathreads_per_collator: 1,

3926

1

                        target_container_chain_fullness: Perbill::from_percent(65),

3927

1

                        max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3928

1

},

3929

1

),

3930

1

3931

1

                    5678u32,

3932

1

                    HostConfigurationV3 {

3933

1

                        max_collators: 1,

3934

1

                        min_orchestrator_collators: 4,

3935

1

                        max_orchestrator_collators: 45,

3936

1

                        collators_per_container: 5,

3937

1

                        full_rotation_period: 1,

3938

1

                        collators_per_parathread: 1,

3939

1

                        parathreads_per_collator: 1,

3940

1

                        target_container_chain_fullness: Perbill::from_percent(65),

3941

1

                        max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3942

1

},

3943

1

),

3944

1

3945

1

            .encode(),

3946

1

);

3947

1

3948

1

        let migration = MigrateConfigurationAddFullRotationMode::<Runtime>(Default::default());

3949

1

        migration.migrate(Default::default());

3950

1

3951

1

        let expected_active = pallet_configuration::HostConfiguration {

3952

1

            max_collators: 5,

3953

1

            min_orchestrator_collators: 2,

3954

1

            max_orchestrator_collators: 1,

3955

1

            collators_per_container: 3,

3956

1

            full_rotation_period: 4,

3957

1

            collators_per_parathread: 2,

3958

1

            parathreads_per_collator: 1,

3959

1

            target_container_chain_fullness: Perbill::from_percent(45),

3960

1

            max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3961

1

            ..Default::default()

3962

1

};

3963

1

        assert_eq!(Configuration::config(), expected_active);

3964

3965

1

        let expected_pending = vec![

3966

1

3967

1

                1234u32,

3968

1

                pallet_configuration::HostConfiguration {

3969

1

                    max_collators: 1,

3970

1

                    min_orchestrator_collators: 4,

3971

1

                    max_orchestrator_collators: 45,

3972

1

                    collators_per_container: 5,

3973

1

                    full_rotation_period: 1,

3974

1

                    collators_per_parathread: 1,

3975

1

                    parathreads_per_collator: 1,

3976

1

                    target_container_chain_fullness: Perbill::from_percent(65),

3977

1

                    max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3978

1

                    ..Default::default()

3979

1

},

3980

1

),

3981

1

3982

1

                5678u32,

3983

1

                pallet_configuration::HostConfiguration {

3984

1

                    max_collators: 1,

3985

1

                    min_orchestrator_collators: 4,

3986

1

                    max_orchestrator_collators: 45,

3987

1

                    collators_per_container: 5,

3988

1

                    full_rotation_period: 1,

3989

1

                    collators_per_parathread: 1,

3990

1

                    parathreads_per_collator: 1,

3991

1

                    target_container_chain_fullness: Perbill::from_percent(65),

3992

1

                    max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3993

1

                    ..Default::default()

3994

1

},

3995

1

),

3996

1

];

3997

1

        assert_eq!(Configuration::pending_configs(), expected_pending);

3998

1

});

3999

1

4000

4001

#[test]

4002

1

fn test_migration_registrar_pending_verification() {

4003

1

    ExtBuilder::default().build().execute_with(|| {

4004

        const REGISTRAR_PENDING_VERIFICATION_KEY: &[u8] =

4005

            &hex_literal::hex!("3fba98689ebed1138735e0e7a5a790ab57a35de516113188134ad8e43c6d55ec");

4006

4007

        // Modify active config

4008

1

        let para_ids: Vec<ParaId> = vec![2000.into(), 2001.into(), 2002.into(), 3000.into()];

4009

1

        frame_support::storage::unhashed::put(REGISTRAR_PENDING_VERIFICATION_KEY, &para_ids);

4010

1

4011

1

        let migration = RegistrarPendingVerificationValueToMap::<Runtime>(Default::default());

4012

1

        migration.migrate(Default::default());

4013

1

4014

1

        let empty_key =

4015

1

            frame_support::storage::unhashed::get_raw(REGISTRAR_PENDING_VERIFICATION_KEY);

4016

1

        assert_eq!(empty_key, None);

4017

4018

5

        for para_id in para_ids {

4019

4

            let exists_in_map =

4020

4

                pallet_registrar::PendingVerification::<Runtime>::get(para_id).is_some();

4021

4

            assert!(

4022

4

                exists_in_map,

4023

                "After migration, para id {:?} does not exist in storage map",

4024

                para_id

4025

);

4026

4027

1

});

4028

1

4029

4030

#[test]

4031

1

fn test_collator_assignment_gives_priority_to_invulnerables() {

4032

1

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

4033

1

    ExtBuilder::default()

4034

1

        .with_balances(vec![

4035

1

            // Alice gets 10k extra tokens for her mapping deposit

4036

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4037

1

            (AccountId::from(BOB), 100_000 * UNIT),

4038

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4039

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4040

1

])

4041

1

        .with_collators(vec![

4042

1

            (AccountId::from(ALICE), 210 * UNIT),

4043

1

            (AccountId::from(DAVE), 100 * UNIT),

4044

1

])

4045

1

        .with_empty_parachains(vec![1001, 1002])

4046

1

        .build()

4047

1

        .execute_with(|| {

4048

1

            run_to_block(2);

4049

1

4050

1

            let stake = 10 * MinimumSelfDelegation::get();

4051

1

4052

1

            // Register accounts in pallet_session (invulnerables are automatically registered)

4053

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4054

1

            assert_ok!(Session::set_keys(

4055

1

                origin_of(BOB.into()),

4056

1

                crate::SessionKeys {

4057

1

                    nimbus: bob_account_id,

4058

1

},

4059

1

                vec![]

4060

1

));

4061

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

4062

1

            assert_ok!(Session::set_keys(

4063

1

                origin_of(CHARLIE.into()),

4064

1

                crate::SessionKeys {

4065

1

                    nimbus: charlie_account_id,

4066

1

},

4067

1

                vec![]

4068

1

));

4069

4070

1

            assert_ok!(PooledStaking::request_delegate(

4071

1

                origin_of(BOB.into()),

4072

1

                BOB.into(),

4073

1

                TargetPool::AutoCompounding,

4074

1

                stake,

4075

1

));

4076

1

            assert_ok!(PooledStaking::request_delegate(

4077

1

                origin_of(CHARLIE.into()),

4078

1

                CHARLIE.into(),

4079

1

                TargetPool::AutoCompounding,

4080

1

                stake,

4081

1

));

4082

4083

1

            let eligible_candidates =

4084

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

4085

1

            assert_eq!(

4086

1

                eligible_candidates,

4087

1

                vec![

4088

1

                    EligibleCandidate {

4089

1

                        candidate: BOB.into(),

4090

1

                        stake

4091

1

},

4092

1

                    EligibleCandidate {

4093

1

                        candidate: CHARLIE.into(),

4094

1

                        stake

4095

1

},

4096

1

4097

1

);

4098

4099

1

            assert_eq!(

4100

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

4101

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

4102

1

);

4103

4104

1

            set_parachain_inherent_data_random_seed([1; 32]);

4105

1

            run_block();

4106

1

4107

1

            // Need to trigger new session to update pallet_session

4108

1

            run_to_session(2);

4109

1

4110

1

            assert_eq!(

4111

1

                Session::validators(),

4112

1

                vec![

4113

1

                    AccountId::from(ALICE),

4114

1

                    AccountId::from(DAVE),

4115

1

                    AccountId::from(BOB),

4116

1

                    AccountId::from(CHARLIE)

4117

1

4118

1

);

4119

4120

            // Need to trigger full rotation to ensure invulnerables are assigned

4121

1

            let rotation_period = Configuration::config().full_rotation_period;

4122

1

            run_to_session(rotation_period);

4123

1

4124

1

            assert!(

4125

1

                CollatorAssignment::collator_container_chain()

4126

1

                    .orchestrator_chain

4127

1

                    .contains(&AccountId::from(ALICE)),

4128

                "CollatorAssignment did not give priority to invulnerable ALICE: {:?}",

4129

                CollatorAssignment::collator_container_chain()

4130

);

4131

4132

1

            assert!(

4133

1

                CollatorAssignment::collator_container_chain()

4134

1

                    .orchestrator_chain

4135

1

                    .contains(&AccountId::from(DAVE)),

4136

                "CollatorAssignment did not give priority to invulnerable DAVE: {:?}",

4137

                CollatorAssignment::collator_container_chain()

4138

);

4139

1

});

4140

1

4141

4142

#[test]

4143

1

fn test_can_buy_credits_before_registering_para() {

4144

1

    ExtBuilder::default()

4145

1

        .with_balances(vec![

4146

1

            // Alice gets 10k extra tokens for her mapping deposit

4147

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4148

1

            (AccountId::from(BOB), 100_000 * UNIT),

4149

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4150

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4151

1

])

4152

1

        .with_collators(vec![

4153

1

            (AccountId::from(ALICE), 210 * UNIT),

4154

1

            (AccountId::from(BOB), 100 * UNIT),

4155

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4156

1

            (AccountId::from(DAVE), 100 * UNIT),

4157

1

])

4158

1

        .build()

4159

1

        .execute_with(|| {

4160

1

            run_to_block(2);

4161

1

4162

1

            // Try to buy the maximum amount of credits

4163

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4164

1

4165

1

            assert_ok!(ServicesPayment::purchase_credits(

4166

1

                origin_of(ALICE.into()),

4167

1

                1001.into(),

4168

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4169

1

));

4170

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4171

1

4172

1

            // Now parachain tank should have this amount

4173

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4174

1

                .data

4175

1

                .free;

4176

1

4177

1

            assert_eq!(

4178

1

                balance_tank,

4179

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4180

1

);

4181

4182

1

            let expected_cost = block_credits_to_required_balance(u32::MAX, 1001.into());

4183

1

            assert_eq!(balance_before - balance_after, expected_cost);

4184

1

});

4185

1

4186

4187

#[test]

4188

1

fn test_cannot_mark_valid_para_with_no_bootnodes() {

4189

1

    ExtBuilder::default()

4190

1

        .with_balances(vec![

4191

1

            // Alice gets 10k extra tokens for her mapping deposit

4192

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4193

1

            (AccountId::from(BOB), 100_000 * UNIT),

4194

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4195

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4196

1

])

4197

1

        .with_collators(vec![

4198

1

            (AccountId::from(ALICE), 210 * UNIT),

4199

1

            (AccountId::from(BOB), 100 * UNIT),

4200

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4201

1

            (AccountId::from(DAVE), 100 * UNIT),

4202

1

])

4203

1

        .build()

4204

1

        .execute_with(|| {

4205

1

            run_to_block(2);

4206

1

            assert_ok!(Registrar::register(

4207

1

                origin_of(ALICE.into()),

4208

1

                1001.into(),

4209

1

                empty_genesis_data(),

4210

1

                None

4211

1

));

4212

1

            assert_noop!(

4213

1

                Registrar::mark_valid_for_collating(root_origin(), 1001.into()),

4214

1

                pallet_data_preservers::Error::<Runtime>::NoBootNodes,

4215

1

);

4216

1

});

4217

1

4218

4219

#[test]

4220

1

fn test_can_buy_credits_before_registering_para_and_receive_free_credits() {

4221

1

    ExtBuilder::default()

4222

1

        .with_balances(vec![

4223

1

            // Alice gets 10k extra tokens for her mapping deposit

4224

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4225

1

            (AccountId::from(BOB), 100_000 * UNIT),

4226

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4227

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4228

1

])

4229

1

        .with_collators(vec![

4230

1

            (AccountId::from(ALICE), 210 * UNIT),

4231

1

            (AccountId::from(BOB), 100 * UNIT),

4232

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4233

1

            (AccountId::from(DAVE), 100 * UNIT),

4234

1

])

4235

1

        .build()

4236

1

        .execute_with(|| {

4237

1

            run_to_block(2);

4238

1

4239

1

            // Try to buy (MaxCreditsStored - 1) credits

4240

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4241

1

            assert_ok!(ServicesPayment::purchase_credits(

4242

1

                origin_of(ALICE.into()),

4243

1

                1001.into(),

4244

1

                block_credits_to_required_balance(

4245

1

                    crate::FreeBlockProductionCredits::get() - 1,

4246

1

                    1001.into()

4247

1

4248

1

));

4249

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4250

1

4251

1

            // Now parachain tank should have this amount

4252

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4253

1

                .data

4254

1

                .free;

4255

1

4256

1

            assert_eq!(

4257

1

                balance_tank,

4258

1

                block_credits_to_required_balance(

4259

1

                    crate::FreeBlockProductionCredits::get() - 1,

4260

1

                    1001.into()

4261

1

4262

1

);

4263

4264

1

            let expected_cost = block_credits_to_required_balance(

4265

1

                crate::FreeBlockProductionCredits::get() - 1,

4266

1

                1001.into(),

4267

1

);

4268

1

            assert_eq!(balance_before - balance_after, expected_cost);

4269

4270

            // Now register para

4271

1

            assert_ok!(Registrar::register(

4272

1

                origin_of(ALICE.into()),

4273

1

                1001.into(),

4274

1

                empty_genesis_data(),

4275

1

                None

4276

1

));

4277

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4278

1

            assert_ok!(Registrar::mark_valid_for_collating(

4279

1

                root_origin(),

4280

1

                1001.into()

4281

1

));

4282

4283

            // We received aññ free credits, because we cannot have more than MaxCreditsStored

4284

1

            let credits =

4285

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4286

1

                    .unwrap_or_default();

4287

1

            assert_eq!(credits, crate::FreeBlockProductionCredits::get());

4288

1

});

4289

1

4290

4291

#[test]

4292

1

fn test_deregister_and_register_again_does_not_give_free_credits() {

4293

1

    ExtBuilder::default()

4294

1

        .with_balances(vec![

4295

1

            // Alice gets 10k extra tokens for her mapping deposit

4296

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4297

1

            (AccountId::from(BOB), 100_000 * UNIT),

4298

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4299

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4300

1

])

4301

1

        .with_collators(vec![

4302

1

            (AccountId::from(ALICE), 210 * UNIT),

4303

1

            (AccountId::from(BOB), 100 * UNIT),

4304

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4305

1

            (AccountId::from(DAVE), 100 * UNIT),

4306

1

])

4307

1

        .build()

4308

1

        .execute_with(|| {

4309

1

            run_to_block(2);

4310

1

4311

1

            // Register

4312

1

            assert_ok!(Registrar::register(

4313

1

                origin_of(ALICE.into()),

4314

1

                1001.into(),

4315

1

                empty_genesis_data(),

4316

1

                None

4317

1

            ),);

4318

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4319

1

            assert_ok!(Registrar::mark_valid_for_collating(

4320

1

                root_origin(),

4321

1

                1001.into()

4322

1

            ),);

4323

            // We received free credits

4324

1

            let credits =

4325

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4326

1

                    .unwrap_or_default();

4327

1

            assert_eq!(credits, crate::FreeBlockProductionCredits::get());

4328

            // Deregister after 1 session

4329

1

            run_to_session(1);

4330

1

            assert_ok!(Registrar::deregister(root_origin(), 1001.into()), ());

4331

4332

1

            run_to_session(3);

4333

1

            let credits_before_2nd_register =

4334

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4335

1

                    .unwrap_or_default();

4336

1

            // We spent some credits because this container chain had collators for 1 session

4337

1

            assert_ne!(

4338

1

                credits_before_2nd_register,

4339

1

                crate::FreeBlockProductionCredits::get()

4340

1

);

4341

            // Register again

4342

1

            assert_ok!(Registrar::register(

4343

1

                origin_of(ALICE.into()),

4344

1

                1001.into(),

4345

1

                empty_genesis_data(),

4346

1

                None

4347

1

            ),);

4348

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4349

1

            assert_ok!(Registrar::mark_valid_for_collating(

4350

1

                root_origin(),

4351

1

                1001.into()

4352

1

            ),);

4353

            // No more free credits

4354

1

            let credits =

4355

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4356

1

                    .unwrap_or_default();

4357

1

            assert_eq!(credits, credits_before_2nd_register);

4358

1

});

4359

1

4360

4361

#[test]

4362

1

fn test_sudo_can_register_foreign_assets_and_manager_change_paremeters() {

4363

1

    ExtBuilder::default()

4364

1

        .with_balances(vec![

4365

1

            // Alice gets 10k extra tokens for her mapping deposit

4366

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4367

1

            (AccountId::from(BOB), 100_000 * UNIT),

4368

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4369

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4370

1

])

4371

1

        .with_collators(vec![

4372

1

            (AccountId::from(ALICE), 210 * UNIT),

4373

1

            (AccountId::from(BOB), 100 * UNIT),

4374

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4375

1

            (AccountId::from(DAVE), 100 * UNIT),

4376

1

])

4377

1

4378

1

        .build()

4379

1

        .execute_with(|| {

4380

1

4381

1

            // We register the asset with Alice as manager

4382

1

            assert_ok!(ForeignAssetsCreator::create_foreign_asset(root_origin(), Location::parent(), 1, AccountId::from(ALICE), true, 1), ());

4383

1

            assert_eq!(ForeignAssetsCreator::foreign_asset_for_id(1), Some(Location::parent()));

4384

1

            assert_eq!(ForeignAssetsCreator::asset_id_for_foreign(Location::parent()), Some(1));

4385

4386

            // Alice now can change parameters like metadata from the asset

4387

1

            assert_ok!(ForeignAssets::set_metadata(origin_of(ALICE.into()), 1, b"xcDot".to_vec(), b"xcDot".to_vec(), 12));

4388

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::name(1),  b"xcDot".to_vec());

4389

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::symbol(1),  b"xcDot".to_vec());

4390

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::decimals(1),  12);

4391

4392

            // Any other person cannot do this

4393

1

            assert_noop!(

4394

1

                ForeignAssets::set_metadata(origin_of(BOB.into()), 1, b"dummy".to_vec(), b"dummy".to_vec(), 12),

4395

1

                pallet_assets::Error::<Runtime, Instance1>::NoPermission

4396

1

);

4397

4398

            // Alice now can mint

4399

1

            assert_ok!(ForeignAssets::mint(origin_of(ALICE.into()), 1, AccountId::from(BOB).into(), 1000));

4400

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::total_issuance(1),  1000);

4401

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::balance(1, &AccountId::from(BOB)),  1000);

4402

1

});

4403

1

4404

4405

#[test]

4406

1

fn test_assets_cannot_be_created_from_signed_origins() {

4407

1

    ExtBuilder::default()

4408

1

        .with_balances(vec![

4409

1

            // Alice gets 10k extra tokens for her mapping deposit

4410

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4411

1

            (AccountId::from(BOB), 100_000 * UNIT),

4412

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4413

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4414

1

])

4415

1

        .with_collators(vec![

4416

1

            (AccountId::from(ALICE), 210 * UNIT),

4417

1

            (AccountId::from(BOB), 100 * UNIT),

4418

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4419

1

            (AccountId::from(DAVE), 100 * UNIT),

4420

1

])

4421

1

        .build()

4422

1

        .execute_with(|| {

4423

1

            // We try to register the asset with Alice as origin

4424

1

            // Any other person cannot do this

4425

1

            assert_noop!(

4426

1

                ForeignAssetsCreator::create_foreign_asset(

4427

1

                    origin_of(ALICE.into()),

4428

1

                    Location::parent(),

4429

1

1,

4430

1

                    AccountId::from(ALICE),

4431

1

                    true,

4432

1

4433

1

),

4434

1

                BadOrigin

4435

1

);

4436

4437

1

            assert_noop!(

4438

1

                ForeignAssets::create(origin_of(ALICE.into()), 1, AccountId::from(ALICE).into(), 1),

4439

1

                BadOrigin

4440

1

);

4441

1

});

4442

1

4443

4444

#[test]

4445

1

fn test_asset_rate_can_be_set_from_sudo_but_not_from_signed() {

4446

1

    ExtBuilder::default()

4447

1

        .with_balances(vec![

4448

1

            // Alice gets 10k extra tokens for her mapping deposit

4449

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4450

1

            (AccountId::from(BOB), 100_000 * UNIT),

4451

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4452

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4453

1

])

4454

1

        .with_collators(vec![

4455

1

            (AccountId::from(ALICE), 210 * UNIT),

4456

1

            (AccountId::from(BOB), 100 * UNIT),

4457

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4458

1

            (AccountId::from(DAVE), 100 * UNIT),

4459

1

])

4460

1

        .build()

4461

1

        .execute_with(|| {

4462

1

            // We try to set the rate from non-sudo

4463

1

            assert_noop!(

4464

1

                AssetRate::create(origin_of(ALICE.into()), Box::new(1), FixedU128::from_u32(1)),

4465

1

                BadOrigin

4466

1

);

4467

4468

            // We try to set the rate from sudo

4469

1

            assert_ok!(AssetRate::create(

4470

1

                root_origin(),

4471

1

                Box::new(1),

4472

1

                FixedU128::from_u32(1)

4473

1

));

4474

4475

1

            assert_eq!(

4476

1

                pallet_asset_rate::ConversionRateToNative::<Runtime>::get(1),

4477

1

                Some(FixedU128::from_u32(1))

4478

1

);

4479

1

});

4480

1

4481

4482

#[test]

4483

1

fn test_division_by_0() {

4484

1

    ExtBuilder::default()

4485

1

        .with_balances(vec![

4486

1

            // Alice gets 10k extra tokens for her mapping deposit

4487

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4488

1

            (AccountId::from(BOB), 100_000 * UNIT),

4489

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4490

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4491

1

])

4492

1

        .with_collators(vec![

4493

1

            (AccountId::from(ALICE), 210 * UNIT),

4494

1

            (AccountId::from(BOB), 100 * UNIT),

4495

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4496

1

            (AccountId::from(DAVE), 100 * UNIT),

4497

1

])

4498

1

        .build()

4499

1

        .execute_with(|| {

4500

1

            // We try to set 0 rate to make sure we dont overflow

4501

1

            assert_ok!(AssetRate::create(

4502

1

                root_origin(),

4503

1

                Box::new(1),

4504

1

                FixedU128::from_u32(0)

4505

1

));

4506

4507

            use frame_support::traits::tokens::ConversionToAssetBalance;

4508

1

            let balance = AssetRate::to_asset_balance(1, 1);

4509

1

            assert!(balance.is_err());

4510

1

});

4511

1

4512

4513

#[test]

4514

1

fn test_register_parathread() {

4515

1

    ExtBuilder::default()

4516

1

        .with_balances(vec![

4517

1

            // Alice gets 10k extra tokens for her mapping deposit

4518

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4519

1

            (AccountId::from(BOB), 100_000 * UNIT),

4520

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4521

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4522

1

])

4523

1

        .with_collators(vec![

4524

1

            (AccountId::from(ALICE), 210 * UNIT),

4525

1

            (AccountId::from(BOB), 100 * UNIT),

4526

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4527

1

            (AccountId::from(DAVE), 100 * UNIT),

4528

1

])

4529

1

        .build()

4530

1

        .execute_with(|| {

4531

1

            run_to_block(2);

4532

1

4533

1

            // Register

4534

1

            assert_ok!(Registrar::register_parathread(

4535

1

                origin_of(ALICE.into()),

4536

1

                3001.into(),

4537

1

                SlotFrequency { min: 1, max: 1 },

4538

1

                empty_genesis_data(),

4539

1

                None

4540

1

));

4541

1

            set_dummy_boot_node(origin_of(ALICE.into()), 3001.into());

4542

1

            assert_ok!(Registrar::mark_valid_for_collating(

4543

1

                root_origin(),

4544

1

                3001.into()

4545

1

));

4546

4547

1

            run_to_session(2);

4548

1

            let assignment = CollatorAssignment::collator_container_chain();

4549

1

            assert_eq!(

4550

1

                assignment.container_chains[&ParaId::from(3001)],

4551

1

                vec![CHARLIE.into()]

4552

1

);

4553

1

});

4554

1

4555

4556

#[test]

4557

1

fn test_register_parathread_genesis() {

4558

1

    let parathread_params = tp_traits::ParathreadParams {

4559

1

        slot_frequency: SlotFrequency { min: 1, max: 1 },

4560

1

};

4561

1

    ExtBuilder::default()

4562

1

        .with_balances(vec![

4563

1

            // Alice gets 10k extra tokens for her mapping deposit

4564

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4565

1

            (AccountId::from(BOB), 100_000 * UNIT),

4566

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4567

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4568

1

])

4569

1

        .with_collators(vec![

4570

1

            (AccountId::from(ALICE), 210 * UNIT),

4571

1

            (AccountId::from(BOB), 100 * UNIT),

4572

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4573

1

            (AccountId::from(DAVE), 100 * UNIT),

4574

1

])

4575

1

        .with_para_ids(vec![ParaRegistrationParams {

4576

1

            para_id: 3001,

4577

1

            genesis_data: empty_genesis_data(),

4578

1

            block_production_credits: u32::MAX,

4579

1

            collator_assignment_credits: u32::MAX,

4580

1

            parathread_params: Some(parathread_params.clone()),

4581

1

}])

4582

1

        .build()

4583

1

        .execute_with(|| {

4584

1

            run_to_block(2);

4585

1

4586

1

            assert_eq!(Registrar::registered_para_ids(), vec![3001.into()]);

4587

1

            assert_eq!(

4588

1

                pallet_registrar::ParathreadParams::<Runtime>::get(ParaId::from(3001)),

4589

1

                Some(parathread_params)

4590

1

);

4591

4592

1

            let assignment = CollatorAssignment::collator_container_chain();

4593

1

            assert_eq!(

4594

1

                assignment.container_chains[&ParaId::from(3001)],

4595

1

                vec![CHARLIE.into()]

4596

1

);

4597

1

});

4598

1

4599

4600

#[test]

4601

1

fn test_ed_plus_block_credit_session_purchase_works() {

4602

1

    ExtBuilder::default()

4603

1

        .with_balances(vec![

4604

1

            // Alice gets 10k extra tokens for her mapping deposit

4605

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4606

1

            (AccountId::from(BOB), 100_000 * UNIT),

4607

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4608

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4609

1

])

4610

1

        .with_collators(vec![

4611

1

            (AccountId::from(ALICE), 210 * UNIT),

4612

1

            (AccountId::from(BOB), 100 * UNIT),

4613

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4614

1

            (AccountId::from(DAVE), 100 * UNIT),

4615

1

])

4616

1

        .build()

4617

1

        .execute_with(|| {

4618

1

            run_to_block(2);

4619

1

            // Assert current slot gets updated

4620

1

            assert_eq!(current_slot(), 1u64);

4621

1

            assert!(current_author() == AccountId::from(BOB));

4622

4623

            // Alice and Bob collate in our chain

4624

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4625

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4626

1

4627

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4628

4629

1

            assert_ok!(Registrar::register(

4630

1

                origin_of(ALICE.into()),

4631

1

                1001.into(),

4632

1

                empty_genesis_data(),

4633

1

                None

4634

1

));

4635

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4636

1

            assert_ok!(Registrar::mark_valid_for_collating(

4637

1

                root_origin(),

4638

1

                1001.into()

4639

1

));

4640

            // Need to reset credits to 0 because now parachains are given free credits on register

4641

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4642

1

                root_origin(),

4643

1

                1001.into(),

4644

1

4645

1

));

4646

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

4647

1

                + crate::EXISTENTIAL_DEPOSIT;

4648

1

4649

1

            // Fill the tank

4650

1

            assert_ok!(ServicesPayment::purchase_credits(

4651

1

                origin_of(ALICE.into()),

4652

1

                1001.into(),

4653

1

                credits_1001

4654

1

));

4655

4656

            // Assignment should happen after 2 sessions

4657

1

            run_to_session(1u32);

4658

1

            let assignment = CollatorAssignment::collator_container_chain();

4659

1

            assert!(assignment.container_chains.is_empty());

4660

1

            run_to_session(2u32);

4661

1

            // Charlie and Dave should be assigned to para 1001

4662

1

            let assignment = CollatorAssignment::collator_container_chain();

4663

1

            assert_eq!(

4664

1

                assignment.container_chains[&1001u32.into()],

4665

1

                vec![CHARLIE.into(), DAVE.into()]

4666

1

);

4667

4668

            // Simulate block inclusion from container chain 1001

4669

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4670

1

            let slot: u64 = 5;

4671

1

            let s = ParaHeaderSproofBuilderItem {

4672

1

                para_id: 1001.into(),

4673

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4674

1

                    parent_hash: Default::default(),

4675

1

                    number: 1,

4676

1

                    state_root: Default::default(),

4677

1

                    extrinsics_root: Default::default(),

4678

1

                    digest: sp_runtime::generic::Digest {

4679

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4680

1

},

4681

1

}),

4682

1

};

4683

1

4684

1

            sproof.items.push(s);

4685

1

            set_author_noting_inherent_data(sproof);

4686

1

4687

1

            run_block();

4688

1

4689

1

            // After this it should not be assigned anymore, since credits are not payable

4690

1

            run_to_session(3u32);

4691

1

            // Nobody should be assigned to para 1001

4692

1

            let assignment = CollatorAssignment::collator_container_chain();

4693

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4694

1

});

4695

1

4696

4697

#[test]

4698

1

fn test_ed_plus_block_credit_session_minus_1_purchase_fails() {

4699

1

    ExtBuilder::default()

4700

1

        .with_balances(vec![

4701

1

            // Alice gets 10k extra tokens for her mapping deposit

4702

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4703

1

            (AccountId::from(BOB), 100_000 * UNIT),

4704

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4705

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4706

1

])

4707

1

        .with_collators(vec![

4708

1

            (AccountId::from(ALICE), 210 * UNIT),

4709

1

            (AccountId::from(BOB), 100 * UNIT),

4710

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4711

1

            (AccountId::from(DAVE), 100 * UNIT),

4712

1

])

4713

1

        .build()

4714

1

        .execute_with(|| {

4715

1

            run_to_block(2);

4716

1

            // Assert current slot gets updated

4717

1

            assert_eq!(current_slot(), 1u64);

4718

1

            assert!(current_author() == AccountId::from(BOB));

4719

4720

            // Alice and Bob collate in our chain

4721

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4722

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4723

1

4724

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4725

4726

1

            assert_ok!(Registrar::register(

4727

1

                origin_of(ALICE.into()),

4728

1

                1001.into(),

4729

1

                empty_genesis_data(),

4730

1

                None

4731

1

));

4732

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4733

1

            assert_ok!(Registrar::mark_valid_for_collating(

4734

1

                root_origin(),

4735

1

                1001.into()

4736

1

));

4737

            // Need to reset credits to 0 because now parachains are given free credits on register

4738

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4739

1

                root_origin(),

4740

1

                1001.into(),

4741

1

4742

1

));

4743

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

4744

1

                + crate::EXISTENTIAL_DEPOSIT

4745

1

                - 1;

4746

1

4747

1

            // Fill the tank

4748

1

            assert_ok!(ServicesPayment::purchase_credits(

4749

1

                origin_of(ALICE.into()),

4750

1

                1001.into(),

4751

1

                credits_1001

4752

1

));

4753

4754

            // Assignment should happen after 2 sessions

4755

1

            run_to_session(1u32);

4756

1

            let assignment = CollatorAssignment::collator_container_chain();

4757

1

            assert!(assignment.container_chains.is_empty());

4758

1

            run_to_session(2u32);

4759

1

            // Charlie and Dave should not be assigned to para 1001

4760

1

            let assignment = CollatorAssignment::collator_container_chain();

4761

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4762

1

});

4763

1

4764

4765

#[test]

4766

1

fn test_reassignment_ed_plus_two_block_credit_session_purchase_works() {

4767

1

    ExtBuilder::default()

4768

1

        .with_balances(vec![

4769

1

            // Alice gets 10k extra tokens for her mapping deposit

4770

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4771

1

            (AccountId::from(BOB), 100_000 * UNIT),

4772

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4773

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4774

1

])

4775

1

        .with_collators(vec![

4776

1

            (AccountId::from(ALICE), 210 * UNIT),

4777

1

            (AccountId::from(BOB), 100 * UNIT),

4778

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4779

1

            (AccountId::from(DAVE), 100 * UNIT),

4780

1

])

4781

1

        .build()

4782

1

        .execute_with(|| {

4783

1

            run_to_block(2);

4784

1

            // Assert current slot gets updated

4785

1

            assert_eq!(current_slot(), 1u64);

4786

1

            assert!(current_author() == AccountId::from(BOB));

4787

4788

            // Alice and Bob collate in our chain

4789

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4790

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4791

1

4792

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4793

4794

1

            assert_ok!(Registrar::register(

4795

1

                origin_of(ALICE.into()),

4796

1

                1001.into(),

4797

1

                empty_genesis_data(),

4798

1

                None

4799

1

));

4800

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4801

1

            assert_ok!(Registrar::mark_valid_for_collating(

4802

1

                root_origin(),

4803

1

                1001.into()

4804

1

));

4805

            // Need to reset credits to 0 because now parachains are given free credits on register

4806

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4807

1

                root_origin(),

4808

1

                1001.into(),

4809

1

4810

1

));

4811

            // On reassignment the blocks credits needed should be enough for the current session and the next one

4812

1

            let credits_1001 =

4813

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into())

4814

1

                    + crate::EXISTENTIAL_DEPOSIT;

4815

1

4816

1

            // Fill the tank

4817

1

            assert_ok!(ServicesPayment::purchase_credits(

4818

1

                origin_of(ALICE.into()),

4819

1

                1001.into(),

4820

1

                credits_1001

4821

1

));

4822

4823

            // Assignment should happen after 2 sessions

4824

1

            run_to_session(1u32);

4825

1

            let assignment = CollatorAssignment::collator_container_chain();

4826

1

            assert!(assignment.container_chains.is_empty());

4827

4828

1

            run_to_session(2u32);

4829

1

            // Charlie and Dave should be assigned to para 1001

4830

1

            let assignment = CollatorAssignment::collator_container_chain();

4831

1

            assert_eq!(

4832

1

                assignment.container_chains[&1001u32.into()],

4833

1

                vec![CHARLIE.into(), DAVE.into()]

4834

1

);

4835

4836

            // Simulate block inclusion from container chain 1001

4837

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4838

1

            let slot: u64 = 5;

4839

1

            let s = ParaHeaderSproofBuilderItem {

4840

1

                para_id: 1001.into(),

4841

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4842

1

                    parent_hash: Default::default(),

4843

1

                    number: 1,

4844

1

                    state_root: Default::default(),

4845

1

                    extrinsics_root: Default::default(),

4846

1

                    digest: sp_runtime::generic::Digest {

4847

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4848

1

},

4849

1

}),

4850

1

};

4851

1

4852

1

            sproof.items.push(s);

4853

1

            set_author_noting_inherent_data(sproof);

4854

1

4855

1

            run_block();

4856

1

4857

1

            // Session 3 should still be assigned

4858

1

            run_to_session(3u32);

4859

1

            // Charlie and Dave should be assigned to para 1001

4860

1

            let assignment = CollatorAssignment::collator_container_chain();

4861

1

            assert_eq!(

4862

1

                assignment.container_chains[&1001u32.into()],

4863

1

                vec![CHARLIE.into(), DAVE.into()]

4864

1

);

4865

4866

            // After this it should not be assigned anymore, since credits are not payable

4867

1

            run_to_session(4u32);

4868

1

            // Nobody should be assigned to para 1001

4869

1

            let assignment = CollatorAssignment::collator_container_chain();

4870

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4871

1

});

4872

1

4873

4874

#[test]

4875

1

fn test_reassignment_ed_plus_two_block_credit_session_minus_1_purchase_fails() {

4876

1

    ExtBuilder::default()

4877

1

        .with_balances(vec![

4878

1

            // Alice gets 10k extra tokens for her mapping deposit

4879

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4880

1

            (AccountId::from(BOB), 100_000 * UNIT),

4881

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4882

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4883

1

])

4884

1

        .with_collators(vec![

4885

1

            (AccountId::from(ALICE), 210 * UNIT),

4886

1

            (AccountId::from(BOB), 100 * UNIT),

4887

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4888

1

            (AccountId::from(DAVE), 100 * UNIT),

4889

1

])

4890

1

        .build()

4891

1

        .execute_with(|| {

4892

1

            run_to_block(2);

4893

1

            // Assert current slot gets updated

4894

1

            assert_eq!(current_slot(), 1u64);

4895

1

            assert!(current_author() == AccountId::from(BOB));

4896

4897

            // Alice and Bob collate in our chain

4898

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4899

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4900

1

4901

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4902

4903

1

            assert_ok!(Registrar::register(

4904

1

                origin_of(ALICE.into()),

4905

1

                1001.into(),

4906

1

                empty_genesis_data(),

4907

1

                None

4908

1

));

4909

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4910

1

            assert_ok!(Registrar::mark_valid_for_collating(

4911

1

                root_origin(),

4912

1

                1001.into()

4913

1

));

4914

            // Need to reset credits to 0 because now parachains are given free credits on register

4915

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4916

1

                root_origin(),

4917

1

                1001.into(),

4918

1

4919

1

));

4920

1

            let credits_1001 =

4921

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into())

4922

1

                    + crate::EXISTENTIAL_DEPOSIT

4923

1

                    - 1;

4924

1

4925

1

            // Fill the tank

4926

1

            assert_ok!(ServicesPayment::purchase_credits(

4927

1

                origin_of(ALICE.into()),

4928

1

                1001.into(),

4929

1

                credits_1001

4930

1

));

4931

4932

            // Assignment should happen after 2 sessions

4933

1

            run_to_session(1u32);

4934

1

            let assignment = CollatorAssignment::collator_container_chain();

4935

1

            assert!(assignment.container_chains.is_empty());

4936

4937

1

            run_to_session(2u32);

4938

1

            // Charlie and Dave should be assigned to para 1001

4939

1

            let assignment = CollatorAssignment::collator_container_chain();

4940

1

            assert_eq!(

4941

1

                assignment.container_chains[&1001u32.into()],

4942

1

                vec![CHARLIE.into(), DAVE.into()]

4943

1

);

4944

4945

            // Simulate block inclusion from container chain 1001

4946

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4947

1

            let slot: u64 = 5;

4948

1

            let s = ParaHeaderSproofBuilderItem {

4949

1

                para_id: 1001.into(),

4950

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4951

1

                    parent_hash: Default::default(),

4952

1

                    number: 1,

4953

1

                    state_root: Default::default(),

4954

1

                    extrinsics_root: Default::default(),

4955

1

                    digest: sp_runtime::generic::Digest {

4956

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4957

1

},

4958

1

}),

4959

1

};

4960

1

4961

1

            sproof.items.push(s);

4962

1

            set_author_noting_inherent_data(sproof);

4963

1

4964

1

            run_block();

4965

1

4966

1

            // After this it should not be assigned anymore, since credits are not payable

4967

1

            run_to_session(3u32);

4968

1

            // Nobody should be assigned to para 1001

4969

1

            let assignment = CollatorAssignment::collator_container_chain();

4970

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4971

1

});

4972

1

4973

4974

#[test]

4975

1

fn test_block_credits_with_purchase_can_be_combined() {

4976

1

    ExtBuilder::default()

4977

1

        .with_balances(vec![

4978

1

            // Alice gets 10k extra tokens for her mapping deposit

4979

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4980

1

            (AccountId::from(BOB), 100_000 * UNIT),

4981

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4982

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4983

1

])

4984

1

        .with_collators(vec![

4985

1

            (AccountId::from(ALICE), 210 * UNIT),

4986

1

            (AccountId::from(BOB), 100 * UNIT),

4987

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4988

1

            (AccountId::from(DAVE), 100 * UNIT),

4989

1

])

4990

1

        .build()

4991

1

        .execute_with(|| {

4992

1

            run_to_block(2);

4993

1

            // Assert current slot gets updated

4994

1

            assert_eq!(current_slot(), 1u64);

4995

1

            assert!(current_author() == AccountId::from(BOB));

4996

4997

            // Alice and Bob collate in our chain

4998

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4999

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5000

1

5001

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5002

5003

1

            assert_ok!(Registrar::register(

5004

1

                origin_of(ALICE.into()),

5005

1

                1001.into(),

5006

1

                empty_genesis_data(),

5007

1

                None

5008

1

));

5009

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5010

1

            assert_ok!(Registrar::mark_valid_for_collating(

5011

1

                root_origin(),

5012

1

                1001.into()

5013

1

));

5014

            // Need to reset credits to 0 because now parachains are given free credits on register

5015

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5016

1

                root_origin(),

5017

1

                1001.into(),

5018

1

                crate::Period::get()

5019

1

));

5020

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

5021

1

                + crate::EXISTENTIAL_DEPOSIT;

5022

1

5023

1

            // Fill the tank

5024

1

            assert_ok!(ServicesPayment::purchase_credits(

5025

1

                origin_of(ALICE.into()),

5026

1

                1001.into(),

5027

1

                credits_1001

5028

1

));

5029

5030

            // Assignment should happen after 2 sessions

5031

1

            run_to_session(1u32);

5032

1

            let assignment = CollatorAssignment::collator_container_chain();

5033

1

            assert!(assignment.container_chains.is_empty());

5034

1

            run_to_session(2u32);

5035

1

            // Charlie and Dave should be assigned to para 1001

5036

1

            let assignment = CollatorAssignment::collator_container_chain();

5037

1

            assert_eq!(

5038

1

                assignment.container_chains[&1001u32.into()],

5039

1

                vec![CHARLIE.into(), DAVE.into()]

5040

1

);

5041

1

});

5042

1

5043

#[test]

5044

1

fn stream_payment_works() {

5045

1

    ExtBuilder::default()

5046

1

        .with_balances(vec![

5047

1

            (AccountId::from(ALICE), 100_000 * UNIT),

5048

1

            (AccountId::from(BOB), 100_000 * UNIT),

5049

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5050

1

])

5051

1

        .with_collators(vec![

5052

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5053

1

            (AccountId::from(DAVE), 100 * UNIT),

5054

1

])

5055

1

        .build()

5056

1

        .execute_with(|| {

5057

            use pallet_stream_payment::{ChangeKind, StreamConfig};

5058

5059

1

            assert_ok!(StreamPayment::open_stream(

5060

1

                origin_of(ALICE.into()),

5061

1

                BOB.into(),

5062

1

                StreamConfig {

5063

1

                    rate: 2 * UNIT,

5064

1

                    asset_id: StreamPaymentAssetId::Native,

5065

1

                    time_unit: TimeUnit::BlockNumber,

5066

1

                    minimum_request_deadline_delay: 0,

5067

1

                    soft_minimum_deposit: 0,

5068

1

},

5069

1

                1_000 * UNIT,

5070

1

));

5071

5072

1

            run_block();

5073

1

5074

1

            assert_ok!(StreamPayment::perform_payment(origin_of(CHARLIE.into()), 0));

5075

1

            assert_eq!(

5076

1

                Balances::free_balance(AccountId::from(BOB)),

5077

1

                100_000 * UNIT + 2 * UNIT

5078

1

);

5079

5080

1

            assert_ok!(StreamPayment::request_change(

5081

1

                origin_of(ALICE.into()),

5082

1

0,

5083

1

                ChangeKind::Suggestion,

5084

1

                StreamConfig {

5085

1

                    rate: 1 * UNIT,

5086

1

                    asset_id: StreamPaymentAssetId::Native,

5087

1

                    time_unit: TimeUnit::BlockNumber,

5088

1

                    minimum_request_deadline_delay: 0,

5089

1

                    soft_minimum_deposit: 0,

5090

1

},

5091

1

                None,

5092

1

));

5093

5094

1

            assert_ok!(StreamPayment::accept_requested_change(

5095

1

                origin_of(BOB.into()),

5096

1

0,

5097

1

                1, // nonce

5098

1

                None,

5099

1

));

5100

5101

1

            run_block();

5102

1

5103

1

            assert_ok!(StreamPayment::close_stream(origin_of(BOB.into()), 0));

5104

5105

1

            assert_eq!(

5106

1

                Balances::free_balance(AccountId::from(BOB)),

5107

1

                100_000 * UNIT + 3 * UNIT

5108

1

);

5109

1

            assert_eq!(

5110

1

                Balances::free_balance(AccountId::from(ALICE)),

5111

1

                100_000 * UNIT - 3 * UNIT

5112

1

);

5113

1

});

5114

1

5115

5116

#[test]

5117

1

fn test_ed_plus_collator_assignment_session_purchase_works() {

5118

1

    ExtBuilder::default()

5119

1

        .with_balances(vec![

5120

1

            // Alice gets 10k extra tokens for her mapping deposit

5121

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5122

1

            (AccountId::from(BOB), 100_000 * UNIT),

5123

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5124

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5125

1

])

5126

1

        .with_collators(vec![

5127

1

            (AccountId::from(ALICE), 210 * UNIT),

5128

1

            (AccountId::from(BOB), 100 * UNIT),

5129

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5130

1

            (AccountId::from(DAVE), 100 * UNIT),

5131

1

])

5132

1

        .build()

5133

1

        .execute_with(|| {

5134

1

            run_to_block(2);

5135

1

            // Assert current slot gets updated

5136

1

            assert_eq!(current_slot(), 1u64);

5137

1

            assert!(current_author() == AccountId::from(BOB));

5138

5139

            // Alice and Bob collate in our chain

5140

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5141

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5142

1

5143

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5144

5145

1

            assert_ok!(Registrar::register(

5146

1

                origin_of(ALICE.into()),

5147

1

                1001.into(),

5148

1

                empty_genesis_data(),

5149

1

                None

5150

1

));

5151

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5152

1

            assert_ok!(Registrar::mark_valid_for_collating(

5153

1

                root_origin(),

5154

1

                1001.into()

5155

1

));

5156

            // Need to reset credits to 0 because now parachains are given free credits on register

5157

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5158

1

                root_origin(),

5159

1

                1001.into(),

5160

1

5161

1

));

5162

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5163

1

                + crate::EXISTENTIAL_DEPOSIT;

5164

1

5165

1

            // Fill the tank

5166

1

            assert_ok!(ServicesPayment::purchase_credits(

5167

1

                origin_of(ALICE.into()),

5168

1

                1001.into(),

5169

1

                credits_1001

5170

1

));

5171

5172

            // Assignment should happen after 2 sessions

5173

1

            run_to_session(1u32);

5174

1

            let assignment = CollatorAssignment::collator_container_chain();

5175

1

            assert!(assignment.container_chains.is_empty());

5176

1

            run_to_session(2u32);

5177

1

            // Charlie and Dave should be assigned to para 1001

5178

1

            let assignment = CollatorAssignment::collator_container_chain();

5179

1

            assert_eq!(

5180

1

                assignment.container_chains[&1001u32.into()],

5181

1

                vec![CHARLIE.into(), DAVE.into()]

5182

1

);

5183

5184

            // Simulate block inclusion from container chain 1001

5185

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

5186

1

            let slot: u64 = 5;

5187

1

            let s = ParaHeaderSproofBuilderItem {

5188

1

                para_id: 1001.into(),

5189

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

5190

1

                    parent_hash: Default::default(),

5191

1

                    number: 1,

5192

1

                    state_root: Default::default(),

5193

1

                    extrinsics_root: Default::default(),

5194

1

                    digest: sp_runtime::generic::Digest {

5195

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

5196

1

},

5197

1

}),

5198

1

};

5199

1

            sproof.items.push(s);

5200

1

            set_author_noting_inherent_data(sproof);

5201

1

5202

1

            run_block();

5203

1

5204

1

            // After this it should not be assigned anymore, since credits are not payable

5205

1

            run_to_session(4u32);

5206

1

            // Nobody should be assigned to para 1001

5207

1

            let assignment = CollatorAssignment::collator_container_chain();

5208

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5209

1

});

5210

1

5211

5212

#[test]

5213

1

fn test_ed_plus_collator_assignment_credit_session_minus_1_purchase_fails() {

5214

1

    ExtBuilder::default()

5215

1

        .with_balances(vec![

5216

1

            // Alice gets 10k extra tokens for her mapping deposit

5217

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5218

1

            (AccountId::from(BOB), 100_000 * UNIT),

5219

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5220

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5221

1

])

5222

1

        .with_collators(vec![

5223

1

            (AccountId::from(ALICE), 210 * UNIT),

5224

1

            (AccountId::from(BOB), 100 * UNIT),

5225

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5226

1

            (AccountId::from(DAVE), 100 * UNIT),

5227

1

])

5228

1

        .build()

5229

1

        .execute_with(|| {

5230

1

            run_to_block(2);

5231

1

            // Assert current slot gets updated

5232

1

            assert_eq!(current_slot(), 1u64);

5233

1

            assert!(current_author() == AccountId::from(BOB));

5234

5235

            // Alice and Bob collate in our chain

5236

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5237

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5238

1

5239

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5240

5241

1

            assert_ok!(Registrar::register(

5242

1

                origin_of(ALICE.into()),

5243

1

                1001.into(),

5244

1

                empty_genesis_data(),

5245

1

                None

5246

1

));

5247

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5248

1

            assert_ok!(Registrar::mark_valid_for_collating(

5249

1

                root_origin(),

5250

1

                1001.into()

5251

1

));

5252

            // Need to reset credits to 0 because now parachains are given free credits on register

5253

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5254

1

                root_origin(),

5255

1

                1001.into(),

5256

1

5257

1

));

5258

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5259

1

                + crate::EXISTENTIAL_DEPOSIT

5260

1

                - 1;

5261

1

5262

1

            // Fill the tank

5263

1

            assert_ok!(ServicesPayment::purchase_credits(

5264

1

                origin_of(ALICE.into()),

5265

1

                1001.into(),

5266

1

                credits_1001

5267

1

));

5268

5269

            // Assignment should happen after 2 sessions

5270

1

            run_to_session(1u32);

5271

1

            let assignment = CollatorAssignment::collator_container_chain();

5272

1

            assert!(assignment.container_chains.is_empty());

5273

1

            run_to_session(2u32);

5274

1

            // Charlie and Dave should not be assigned to para 1001

5275

1

            let assignment = CollatorAssignment::collator_container_chain();

5276

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5277

1

});

5278

1

5279

5280

#[test]

5281

1

fn test_collator_assignment_credits_with_purchase_can_be_combined() {

5282

1

    ExtBuilder::default()

5283

1

        .with_balances(vec![

5284

1

            // Alice gets 10k extra tokens for her mapping deposit

5285

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5286

1

            (AccountId::from(BOB), 100_000 * UNIT),

5287

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5288

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5289

1

])

5290

1

        .with_collators(vec![

5291

1

            (AccountId::from(ALICE), 210 * UNIT),

5292

1

            (AccountId::from(BOB), 100 * UNIT),

5293

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5294

1

            (AccountId::from(DAVE), 100 * UNIT),

5295

1

])

5296

1

        .build()

5297

1

        .execute_with(|| {

5298

1

            run_to_block(2);

5299

1

            // Assert current slot gets updated

5300

1

            assert_eq!(current_slot(), 1u64);

5301

1

            assert!(current_author() == AccountId::from(BOB));

5302

5303

            // Alice and Bob collate in our chain

5304

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5305

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5306

1

5307

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5308

5309

1

            assert_ok!(Registrar::register(

5310

1

                origin_of(ALICE.into()),

5311

1

                1001.into(),

5312

1

                empty_genesis_data(),

5313

1

                None

5314

1

));

5315

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5316

1

            assert_ok!(Registrar::mark_valid_for_collating(

5317

1

                root_origin(),

5318

1

                1001.into()

5319

1

));

5320

5321

            // We assign one session to free credits

5322

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5323

1

                root_origin(),

5324

1

                1001.into(),

5325

1

5326

1

));

5327

            // We buy another session through the tank

5328

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5329

1

                + crate::EXISTENTIAL_DEPOSIT;

5330

1

5331

1

            // Fill the tank

5332

1

            assert_ok!(ServicesPayment::purchase_credits(

5333

1

                origin_of(ALICE.into()),

5334

1

                1001.into(),

5335

1

                credits_1001

5336

1

));

5337

5338

            // Assignment should happen after 2 sessions

5339

1

            run_to_session(1u32);

5340

1

            let assignment = CollatorAssignment::collator_container_chain();

5341

1

            assert!(assignment.container_chains.is_empty());

5342

1

            run_to_session(2u32);

5343

1

            // Charlie and Dave should be assigned to para 1001

5344

1

            let assignment = CollatorAssignment::collator_container_chain();

5345

1

            assert_eq!(

5346

1

                assignment.container_chains[&1001u32.into()],

5347

1

                vec![CHARLIE.into(), DAVE.into()]

5348

1

);

5349

1

});

5350

1

5351

5352

#[test]

5353

1

fn test_block_credits_and_collator_assignation_credits_through_tank() {

5354

1

    ExtBuilder::default()

5355

1

        .with_balances(vec![

5356

1

            // Alice gets 10k extra tokens for her mapping deposit

5357

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5358

1

            (AccountId::from(BOB), 100_000 * UNIT),

5359

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5360

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5361

1

])

5362

1

        .with_collators(vec![

5363

1

            (AccountId::from(ALICE), 210 * UNIT),

5364

1

            (AccountId::from(BOB), 100 * UNIT),

5365

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5366

1

            (AccountId::from(DAVE), 100 * UNIT),

5367

1

])

5368

1

        .build()

5369

1

        .execute_with(|| {

5370

1

            run_to_block(2);

5371

1

            // Assert current slot gets updated

5372

1

            assert_eq!(current_slot(), 1u64);

5373

1

            assert!(current_author() == AccountId::from(BOB));

5374

5375

            // Alice and Bob collate in our chain

5376

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5377

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5378

1

5379

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5380

5381

1

            assert_ok!(Registrar::register(

5382

1

                origin_of(ALICE.into()),

5383

1

                1001.into(),

5384

1

                empty_genesis_data(),

5385

1

                None

5386

1

));

5387

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5388

1

            assert_ok!(Registrar::mark_valid_for_collating(

5389

1

                root_origin(),

5390

1

                1001.into()

5391

1

));

5392

5393

            // We make all free credits 0

5394

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5395

1

                root_origin(),

5396

1

                1001.into(),

5397

1

5398

1

));

5399

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5400

1

                root_origin(),

5401

1

                1001.into(),

5402

1

5403

1

));

5404

5405

            // We buy 2 sessions through tank

5406

1

            let collator_assignation_credits =

5407

1

                collator_assignment_credits_to_required_balance(2, 1001.into());

5408

1

            let block_production_credits =

5409

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into());

5410

1

5411

1

            // Fill the tank

5412

1

            assert_ok!(ServicesPayment::purchase_credits(

5413

1

                origin_of(ALICE.into()),

5414

1

                1001.into(),

5415

1

                collator_assignation_credits

5416

1

                    + block_production_credits

5417

1

                    + crate::EXISTENTIAL_DEPOSIT

5418

1

));

5419

5420

            // Assignment should happen after 2 sessions

5421

1

            run_to_session(1u32);

5422

1

            let assignment = CollatorAssignment::collator_container_chain();

5423

1

            assert!(assignment.container_chains.is_empty());

5424

1

            run_to_session(2u32);

5425

1

            // Charlie and Dave should be assigned to para 1001

5426

1

            let assignment = CollatorAssignment::collator_container_chain();

5427

1

            assert_eq!(

5428

1

                assignment.container_chains[&1001u32.into()],

5429

1

                vec![CHARLIE.into(), DAVE.into()]

5430

1

);

5431

5432

            // After this it should not be assigned anymore, since credits are not payable

5433

1

            run_to_session(4u32);

5434

1

            // Nobody should be assigned to para 1001

5435

1

            let assignment = CollatorAssignment::collator_container_chain();

5436

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5437

1

});

5438

1

5439

5440

#[test]

5441

1

fn test_migration_services_collator_assignment_payment() {

5442

1

    ExtBuilder::default().build().execute_with(|| {

5443

1

        // Register a new parachain with no credits

5444

1

        assert_ok!(Registrar::register(

5445

1

            origin_of(ALICE.into()),

5446

1

            1001.into(),

5447

1

            empty_genesis_data(),

5448

1

            None

5449

1

));

5450

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5451

1

        assert_ok!(Registrar::mark_valid_for_collating(

5452

1

            root_origin(),

5453

1

            1001.into()

5454

1

));

5455

        // Register another parachain with no credits, do not mark this as valid for collation

5456

1

        assert_ok!(Registrar::register(

5457

1

            origin_of(ALICE.into()),

5458

1

            1002.into(),

5459

1

            empty_genesis_data(),

5460

1

            None

5461

1

));

5462

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1002.into());

5463

1

        assert_ok!(Registrar::mark_valid_for_collating(

5464

1

            root_origin(),

5465

1

            1002.into()

5466

1

));

5467

5468

        // Need to reset credits to 0 because now parachains are given free credits on register

5469

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

5470

1

            root_origin(),

5471

1

            1001.into(),

5472

1

5473

1

));

5474

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

5475

1

            root_origin(),

5476

1

            1002.into(),

5477

1

5478

1

));

5479

5480

1

        let credits_1001 =

5481

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

5482

1

                .unwrap_or_default();

5483

1

        assert_eq!(credits_1001, 0);

5484

1

        let credits_1002 =

5485

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

5486

1

                .unwrap_or_default();

5487

1

        assert_eq!(credits_1002, 0);

5488

5489

        // Apply migration

5490

1

        let migration =

5491

1

            MigrateServicesPaymentAddCollatorAssignmentCredits::<Runtime>(Default::default());

5492

1

        migration.migrate(Default::default());

5493

1

5494

1

        // Both parachains have been given credits

5495

1

        let credits_1001 =

5496

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

5497

1

                .unwrap_or_default();

5498

1

        assert_eq!(credits_1001, crate::FreeCollatorAssignmentCredits::get());

5499

1

        let credits_1002 =

5500

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

5501

1

                .unwrap_or_default();

5502

1

        assert_eq!(credits_1002, crate::FreeCollatorAssignmentCredits::get());

5503

1

});

5504

1

5505

5506

#[test]

5507

1

fn test_max_collators_uses_pending_value() {

5508

1

    // Start with max_collators = 100, and collators_per_container = 2

5509

1

    // Set max_collators = 2, and collators_per_container = 3

5510

1

    // It should be impossible to have more than 2 collators per container at any point in time

5511

1

    ExtBuilder::default()

5512

1

        .with_balances(vec![

5513

1

            // Alice gets 10k extra tokens for her mapping deposit

5514

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5515

1

            (AccountId::from(BOB), 100_000 * UNIT),

5516

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5517

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5518

1

])

5519

1

        .with_collators(vec![

5520

1

            (AccountId::from(ALICE), 210 * UNIT),

5521

1

            (AccountId::from(BOB), 100 * UNIT),

5522

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5523

1

            (AccountId::from(DAVE), 100 * UNIT),

5524

1

])

5525

1

        .with_empty_parachains(vec![1001])

5526

1

        .with_config(pallet_configuration::HostConfiguration {

5527

1

            max_collators: 100,

5528

1

            min_orchestrator_collators: 1,

5529

1

            max_orchestrator_collators: 1,

5530

1

            collators_per_container: 2,

5531

1

            full_rotation_period: 24,

5532

1

            ..Default::default()

5533

1

})

5534

1

        .build()

5535

1

        .execute_with(|| {

5536

1

            run_to_block(2);

5537

1

5538

1

            // Initial assignment: 1 collator in orchestrator chain and 2 collators in container 1001

5539

1

            let assignment = CollatorAssignment::collator_container_chain();

5540

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 2);

5541

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5542

5543

1

            assert_ok!(Configuration::set_max_collators(root_origin(), 2));

5544

1

            assert_ok!(Configuration::set_collators_per_container(root_origin(), 3));

5545

5546

            // Check invariant for all intermediate assignments. We set collators_per_container = 3

5547

            // but we also set max_collators = 2, so no collators will be assigned to container

5548

            // chains after the change is applied.

5549

5

            for session in 1..=4 {

5550

4

                run_to_session(session);

5551

4

5552

4

                let assignment = CollatorAssignment::collator_container_chain();

5553

4

                assert!(

5554

4

                    assignment.container_chains[&1001u32.into()].len() <= 2,

5555

                    "session {}: {} collators assigned to container chain 1001",

5556

                    session,

5557

                    assignment.container_chains[&1001u32.into()].len()

5558

);

5559

5560

5561

            // Final assignment: because max_collators = 2, there are only 2 collators, one in

5562

            // orchestrator chain, and the other one idle

5563

1

            let assignment = CollatorAssignment::collator_container_chain();

5564

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 0);

5565

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5566

1

});

5567

1

5568

5569

#[test]

5570

1

fn test_slow_adjusting_multiplier_changes_in_response_to_consumed_weight() {

5571

1

    ExtBuilder::default()

5572

1

        .with_collators(vec![

5573

1

            (AccountId::from(ALICE), 210 * UNIT),

5574

1

            (AccountId::from(BOB), 100 * UNIT),

5575

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5576

1

            (AccountId::from(DAVE), 100 * UNIT),

5577

1

])

5578

1

        .build()

5579

1

        .execute_with(|| {

5580

1

            end_block();

5581

1

            // If the block is full, the multiplier increases

5582

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5583

1

            start_block();

5584

1

            let max_block_weights = crate::RuntimeBlockWeights::get();

5585

1

            frame_support::storage::unhashed::put(

5586

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5587

3

                &ConsumedWeight::new(|class| {

5588

3

                    max_block_weights

5589

3

                        .get(class)

5590

3

                        .max_total

5591

3

                        .unwrap_or(Weight::MAX)

5592

3

}),

5593

1

);

5594

1

            end_block();

5595

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5596

1

            assert!(current_multiplier > before_multiplier);

5597

5598

            // If the block is empty, the multiplier decreases

5599

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5600

1

            start_block();

5601

1

            frame_support::storage::unhashed::put(

5602

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5603

3

                &ConsumedWeight::new(|_class| Weight::zero()),

5604

1

);

5605

1

            end_block();

5606

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5607

1

            assert!(current_multiplier < before_multiplier);

5608

1

});

5609

1

5610

5611

#[test]

5612

1

fn test_collator_assignment_tip_priority_on_congestion() {

5613

1

    ExtBuilder::default()

5614

1

        .with_balances(vec![

5615

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5616

1

            (AccountId::from(BOB), 100_000 * UNIT),

5617

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5618

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5619

1

])

5620

1

        .with_collators(vec![

5621

1

            (AccountId::from(ALICE), 210 * UNIT),

5622

1

            (AccountId::from(BOB), 100 * UNIT),

5623

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5624

1

            (AccountId::from(DAVE), 100 * UNIT),

5625

1

])

5626

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5627

1

        .build()

5628

1

        .execute_with(|| {

5629

1

            let para_id = 1003u32;

5630

1

            let tank_funds = 100 * UNIT;

5631

1

            let max_tip = 1 * UNIT;

5632

1

5633

1

            assert_eq!(

5634

1

                CollatorAssignment::collator_container_chain().container_chains[&1003u32.into()]

5635

1

                    .len(),

5636

1

5637

1

);

5638

5639

            // Send funds to tank

5640

1

            assert_ok!(ServicesPayment::purchase_credits(

5641

1

                origin_of(ALICE.into()),

5642

1

                para_id.into(),

5643

1

                tank_funds,

5644

1

));

5645

5646

            // Set tip for 1003

5647

1

            assert_ok!(ServicesPayment::set_max_tip(

5648

1

                root_origin(),

5649

1

                para_id.into(),

5650

1

                Some(max_tip),

5651

1

));

5652

5653

1

            run_to_session(2);

5654

1

            assert_eq!(

5655

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5656

1

                    .len(),

5657

1

2,

5658

1

);

5659

1

});

5660

1

5661

5662

#[test]

5663

1

fn test_collator_assignment_tip_charged_on_congestion() {

5664

1

    ExtBuilder::default()

5665

1

        .with_balances(vec![

5666

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5667

1

            (AccountId::from(BOB), 100_000 * UNIT),

5668

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5669

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5670

1

])

5671

1

        .with_collators(vec![

5672

1

            (AccountId::from(ALICE), 210 * UNIT),

5673

1

            (AccountId::from(BOB), 100 * UNIT),

5674

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5675

1

            (AccountId::from(DAVE), 100 * UNIT),

5676

1

])

5677

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5678

1

        .build()

5679

1

        .execute_with(|| {

5680

1

            let tank_funds = 100 * UNIT;

5681

1

            let max_tip = 1 * UNIT;

5682

1

            let para_id = 1003u32;

5683

1

5684

1

            // Send funds to tank

5685

1

            assert_ok!(ServicesPayment::purchase_credits(

5686

1

                origin_of(ALICE.into()),

5687

1

                para_id.into(),

5688

1

                tank_funds,

5689

1

));

5690

5691

            // Set tip for para_id

5692

1

            assert_ok!(ServicesPayment::set_max_tip(

5693

1

                root_origin(),

5694

1

                para_id.into(),

5695

1

                Some(max_tip),

5696

1

));

5697

5698

1

            run_to_session(1);

5699

1

            assert_eq!(

5700

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id.into())),

5701

1

                tank_funds - max_tip,

5702

1

);

5703

1

});

5704

1

5705

5706

#[test]

5707

1

fn test_collator_assignment_tip_not_assigned_on_insufficient_balance() {

5708

1

    ExtBuilder::default()

5709

1

        .with_balances(vec![

5710

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5711

1

            (AccountId::from(BOB), 100_000 * UNIT),

5712

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5713

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5714

1

])

5715

1

        .with_collators(vec![

5716

1

            (AccountId::from(ALICE), 210 * UNIT),

5717

1

            (AccountId::from(BOB), 100 * UNIT),

5718

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5719

1

            (AccountId::from(DAVE), 100 * UNIT),

5720

1

])

5721

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5722

1

        .build()

5723

1

        .execute_with(|| {

5724

1

            let tank_funds = 1 * UNIT;

5725

1

            let max_tip = 1 * UNIT;

5726

1

            let para_id = 1003u32;

5727

1

5728

1

            // Send insufficient funds to tank for tip for 2 sessions

5729

1

            assert_ok!(ServicesPayment::purchase_credits(

5730

1

                origin_of(ALICE.into()),

5731

1

                para_id.into(),

5732

1

                tank_funds,

5733

1

));

5734

5735

            // Set tip for para_id

5736

1

            assert_ok!(ServicesPayment::set_max_tip(

5737

1

                root_origin(),

5738

1

                para_id.into(),

5739

1

                Some(max_tip),

5740

1

));

5741

5742

1

            run_to_session(1);

5743

1

            assert_eq!(

5744

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5745

1

                    .len(),

5746

1

5747

1

);

5748

1

});

5749

1

5750

5751

#[test]

5752

1

fn test_collator_assignment_tip_only_charge_willing_paras() {

5753

1

    ExtBuilder::default()

5754

1

        .with_balances(vec![

5755

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5756

1

            (AccountId::from(BOB), 100_000 * UNIT),

5757

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5758

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5759

1

            (AccountId::from(EVE), 100_000 * UNIT),

5760

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5761

1

])

5762

1

        .with_collators(vec![

5763

1

            (AccountId::from(ALICE), 210 * UNIT),

5764

1

            (AccountId::from(BOB), 100 * UNIT),

5765

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5766

1

            (AccountId::from(DAVE), 100 * UNIT),

5767

1

            (AccountId::from(EVE), 100 * UNIT),

5768

1

            (AccountId::from(FERDIE), 100 * UNIT),

5769

1

])

5770

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5771

1

        .build()

5772

1

        .execute_with(|| {

5773

1

            let tank_funds = 100 * UNIT;

5774

1

            let max_tip = 1 * UNIT;

5775

1

            let para_id_with_tip = 1003u32;

5776

1

            let para_id_without_tip = 1001u32;

5777

1

5778

1

            // Send funds to tank to both paras

5779

1

            assert_ok!(ServicesPayment::purchase_credits(

5780

1

                origin_of(ALICE.into()),

5781

1

                para_id_with_tip.into(),

5782

1

                tank_funds,

5783

1

));

5784

1

            assert_ok!(ServicesPayment::purchase_credits(

5785

1

                origin_of(ALICE.into()),

5786

1

                para_id_without_tip.into(),

5787

1

                tank_funds,

5788

1

));

5789

5790

            // Only set tip for 1003

5791

1

            assert_ok!(ServicesPayment::set_max_tip(

5792

1

                root_origin(),

5793

1

                para_id_with_tip.into(),

5794

1

                Some(max_tip),

5795

1

));

5796

5797

1

            run_to_session(2);

5798

1

5799

1

            let assignment = CollatorAssignment::collator_container_chain().container_chains;

5800

1

5801

1

            // 2 out of the 3 paras should have collators assigned, with one paying tip to get

5802

1

            // prioritized, and the other selected at random that should not be charged any tips

5803

1

            assert_eq!(assignment[&para_id_with_tip.into()].len(), 2);

5804

1

            assert_eq!(

5805

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_with_tip.into())),

5806

1

                tank_funds - max_tip * 2,

5807

1

);

5808

5809

1

            assert_eq!(assignment[&para_id_without_tip.into()].len(), 2);

5810

1

            assert_eq!(

5811

1

                Balances::usable_balance(ServicesPayment::parachain_tank(

5812

1

                    para_id_without_tip.into()

5813

1

)),

5814

1

                tank_funds,

5815

1

);

5816

1

});

5817

1

5818

5819

#[test]

5820

1

fn test_collator_assignment_tip_withdraw_min_tip() {

5821

1

    ExtBuilder::default()

5822

1

        .with_balances(vec![

5823

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5824

1

            (AccountId::from(BOB), 100_000 * UNIT),

5825

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5826

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5827

1

            (AccountId::from(EVE), 100_000 * UNIT),

5828

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5829

1

])

5830

1

        .with_collators(vec![

5831

1

            (AccountId::from(ALICE), 210 * UNIT),

5832

1

            (AccountId::from(BOB), 100 * UNIT),

5833

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5834

1

            (AccountId::from(DAVE), 100 * UNIT),

5835

1

            (AccountId::from(EVE), 100 * UNIT),

5836

1

            (AccountId::from(FERDIE), 100 * UNIT),

5837

1

])

5838

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5839

1

        .build()

5840

1

        .execute_with(|| {

5841

1

            let tank_funds = 100 * UNIT;

5842

1

            let max_tip_1003 = 3 * UNIT;

5843

1

            let max_tip_1002 = 2 * UNIT;

5844

1

            let para_id_1003 = 1003u32;

5845

1

            let para_id_1002 = 1002u32;

5846

1

5847

1

            // Send funds to tank to both paras

5848

1

            assert_ok!(ServicesPayment::purchase_credits(

5849

1

                origin_of(ALICE.into()),

5850

1

                para_id_1003.into(),

5851

1

                tank_funds,

5852

1

));

5853

1

            assert_ok!(ServicesPayment::purchase_credits(

5854

1

                origin_of(ALICE.into()),

5855

1

                para_id_1002.into(),

5856

1

                tank_funds,

5857

1

));

5858

5859

            // Set tips

5860

1

            assert_ok!(ServicesPayment::set_max_tip(

5861

1

                root_origin(),

5862

1

                para_id_1003.into(),

5863

1

                Some(max_tip_1003),

5864

1

));

5865

1

            assert_ok!(ServicesPayment::set_max_tip(

5866

1

                root_origin(),

5867

1

                para_id_1002.into(),

5868

1

                Some(max_tip_1002),

5869

1

));

5870

5871

1

            run_to_session(2);

5872

1

5873

1

            assert_eq!(

5874

1

                CollatorAssignment::collator_container_chain().container_chains

5875

1

                    [&para_id_1003.into()]

5876

1

                    .len(),

5877

1

5878

1

);

5879

1

            assert_eq!(

5880

1

                CollatorAssignment::collator_container_chain().container_chains

5881

1

                    [&para_id_1002.into()]

5882

1

                    .len(),

5883

1

5884

1

);

5885

5886

            // Should have withdrawn the lowest tip from both paras

5887

1

            assert_eq!(

5888

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1003.into())),

5889

1

                tank_funds - max_tip_1002 * 2,

5890

1

);

5891

5892

1

            assert_eq!(

5893

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1002.into())),

5894

1

                tank_funds - max_tip_1002 * 2,

5895

1

);

5896

1

});

5897

1

5898

5899

#[test]

5900

1

fn test_migration_data_preservers_assignments() {

5901

1

    ExtBuilder::default().build().execute_with(|| {

5902

        use {

5903

            crate::{MaxAssignmentsPerParaId, MaxNodeUrlLen},

5904

            frame_support::{

5905

                migration::{have_storage_value, put_storage_value},

5906

                Blake2_128Concat, StorageHasher,

5907

},

5908

            pallet_data_preservers::{ParaIdsFilter, Profile, ProfileMode, RegisteredProfile},

5909

            sp_runtime::BoundedBTreeSet,

5910

            sp_std::collections::btree_set::BTreeSet,

5911

            tanssi_runtime_common::migrations::DataPreserversAssignmentsMigration,

5912

};

5913

5914

        macro_rules! bset {

5915

            ( $($value:expr),* $(,)? ) => {

5916

5917

                    let mut set = BoundedBTreeSet::new();

5918

$(

5919

                        set.try_insert($value).expect("max bound reached");

5920

)*

5921

set

5922

5923

5924

5925

5926

        macro_rules! set {

5927

            ( $($value:expr),* $(,)? ) => {

5928

5929

                    let mut set = BTreeSet::new();

5930

$(

5931

                        set.insert($value);

5932

)*

5933

set

5934

5935

5936

5937

5938

1

        let account = AccountId::from([0u8; 32]);

5939

1

        let free_request = crate::PreserversAssignementPaymentRequest::Free;

5940

1

        let free_witness = crate::PreserversAssignementPaymentWitness::Free;

5941

1

5942

1

        let pallet_prefix: &[u8] = b"DataPreservers";

5943

1

        let storage_item_prefix: &[u8] = b"BootNodes";

5944

1

5945

1

        // Register 2 parachains

5946

1

        assert_ok!(Registrar::register(

5947

1

            origin_of(ALICE.into()),

5948

1

            1001.into(),

5949

1

            empty_genesis_data(),

5950

1

            None

5951

1

));

5952

1

        assert_ok!(Registrar::register(

5953

1

            origin_of(BOB.into()),

5954

1

            1002.into(),

5955

1

            empty_genesis_data(),

5956

1

            None

5957

1

));

5958

5959

        // Set bootnodes in old storage

5960

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

5961

1

            b"alpha".to_vec().try_into().unwrap(),

5962

1

            b"beta".to_vec().try_into().unwrap(),

5963

1

5964

1

        .try_into()

5965

1

        .unwrap();

5966

1

        put_storage_value(

5967

1

            pallet_prefix,

5968

1

            storage_item_prefix,

5969

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode()),

5970

1

            bootnodes,

5971

1

);

5972

1

5973

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

5974

1

            b"delta".to_vec().try_into().unwrap(),

5975

1

            b"gamma".to_vec().try_into().unwrap(),

5976

1

5977

1

        .try_into()

5978

1

        .unwrap();

5979

1

        put_storage_value(

5980

1

            pallet_prefix,

5981

1

            storage_item_prefix,

5982

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode()),

5983

1

            bootnodes,

5984

1

);

5985

1

5986

1

        // Apply migration

5987

1

        let migration = DataPreserversAssignmentsMigration::<Runtime>(Default::default());

5988

1

        migration.migrate(Default::default());

5989

1

5990

1

        // Check old storage is empty

5991

1

        assert!(!have_storage_value(

5992

1

            pallet_prefix,

5993

1

            storage_item_prefix,

5994

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode())

5995

1

));

5996

1

        assert!(!have_storage_value(

5997

1

            pallet_prefix,

5998

1

            storage_item_prefix,

5999

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode())

6000

1

));

6001

6002

        // Check new storage

6003

1

        assert_eq!(

6004

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1001)).into_inner(),

6005

1

            set![0, 1]

6006

1

);

6007

1

        assert_eq!(

6008

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1002)).into_inner(),

6009

1

            set![2, 3]

6010

1

);

6011

1

        assert_eq!(pallet_data_preservers::NextProfileId::<Runtime>::get(), 4);

6012

1

        assert_eq!(

6013

1

            pallet_data_preservers::Profiles::<Runtime>::get(0),

6014

1

            Some(RegisteredProfile {

6015

1

                account: account.clone(),

6016

1

                deposit: 0,

6017

1

                assignment: Some((1001.into(), free_witness)),

6018

1

                profile: Profile {

6019

1

                    url: b"alpha".to_vec().try_into().unwrap(),

6020

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

6021

1

                    mode: ProfileMode::Bootnode,

6022

1

                    assignment_request: free_request,

6023

1

6024

1

})

6025

1

);

6026

1

        assert_eq!(

6027

1

            pallet_data_preservers::Profiles::<Runtime>::get(1),

6028

1

            Some(RegisteredProfile {

6029

1

                account: account.clone(),

6030

1

                deposit: 0,

6031

1

                assignment: Some((1001.into(), free_witness)),

6032

1

                profile: Profile {

6033

1

                    url: b"beta".to_vec().try_into().unwrap(),

6034

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

6035

1

                    mode: ProfileMode::Bootnode,

6036

1

                    assignment_request: free_request,

6037

1

6038

1

})

6039

1

);

6040

1

        assert_eq!(

6041

1

            pallet_data_preservers::Profiles::<Runtime>::get(2),

6042

1

            Some(RegisteredProfile {

6043

1

                account: account.clone(),

6044

1

                deposit: 0,

6045

1

                assignment: Some((1002.into(), free_witness)),

6046

1

                profile: Profile {

6047

1

                    url: b"delta".to_vec().try_into().unwrap(),

6048

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

6049

1

                    mode: ProfileMode::Bootnode,

6050

1

                    assignment_request: free_request,

6051

1

6052

1

})

6053

1

);

6054

1

        assert_eq!(

6055

1

            pallet_data_preservers::Profiles::<Runtime>::get(3),

6056

1

            Some(RegisteredProfile {

6057

1

                account: account.clone(),

6058

1

                deposit: 0,

6059

1

                assignment: Some((1002.into(), free_witness)),

6060

1

                profile: Profile {

6061

1

                    url: b"gamma".to_vec().try_into().unwrap(),

6062

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

6063

1

                    mode: ProfileMode::Bootnode,

6064

1

                    assignment_request: free_request,

6065

1

6066

1

})

6067

1

);

6068

1

})

6069

1

6070

6071

#[test]

6072

1

fn test_migration_registrar_reserves_to_hold() {

6073

1

    ExtBuilder::default()

6074

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

6075

1

        .build()

6076

1

        .execute_with(|| {

6077

            use {

6078

                frame_support::traits::{fungible::InspectHold, ReservableCurrency},

6079

                pallet_registrar::DepositInfo,

6080

                tanssi_runtime_common::migrations::RegistrarReserveToHoldMigration,

6081

};

6082

6083

1

            let deposit: Balance = 100 * UNIT;

6084

1

            let account: AccountId = DAVE.into();

6085

1

6086

1

            assert_ok!(Balances::reserve(&account, deposit));

6087

6088

1

            pallet_registrar::RegistrarDeposit::<Runtime>::insert(

6089

1

                ParaId::from(1001),

6090

1

                DepositInfo {

6091

1

                    creator: account.clone(),

6092

1

                    deposit,

6093

1

},

6094

1

);

6095

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

6096

            // Apply migration

6097

1

            let migration = RegistrarReserveToHoldMigration::<Runtime>(Default::default());

6098

1

            migration.migrate(Default::default());

6099

1

6100

1

            // Holds also count as reserved balance, so the total reserved amount

6101

1

            // shouldn't change after the migration

6102

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

6103

6104

1

            assert_eq!(

6105

1

                Balances::balance_on_hold(

6106

1

                    &pallet_registrar::HoldReason::RegistrarDeposit.into(),

6107

1

                    &account

6108

1

),

6109

1

                deposit

6110

1

);

6111

1

})

6112

1

6113

6114

#[test]

6115

1

fn test_migration_stream_payment_config_new_fields() {

6116

1

    ExtBuilder::default().build().execute_with(|| {

6117

        use pallet_stream_payment::{

6118

            migrations::{OldChangeRequest, OldStream, OldStreamConfig},

6119

            ChangeKind, ChangeRequest, DepositChange, Party, Stream, StreamConfig,

6120

};

6121

        use tanssi_runtime_common::migrations::MigrateStreamPaymentNewConfigFields;

6122

6123

1

        frame_support::storage::unhashed::put(

6124

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(0),

6125

1

            &OldStream::<AccountId, TimeUnit, StreamPaymentAssetId, Balance> {

6126

1

                source: ALICE.into(),

6127

1

                target: BOB.into(),

6128

1

                config: OldStreamConfig {

6129

1

                    time_unit: TimeUnit::Timestamp,

6130

1

                    asset_id: StreamPaymentAssetId::Native,

6131

1

                    rate: 41,

6132

1

},

6133

1

                deposit: 42,

6134

1

                last_time_updated: 43,

6135

1

                request_nonce: 44,

6136

1

                pending_request: Some(OldChangeRequest {

6137

1

                    requester: Party::Source,

6138

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

6139

1

                    new_config: OldStreamConfig {

6140

1

                        time_unit: TimeUnit::BlockNumber,

6141

1

                        asset_id: StreamPaymentAssetId::Native,

6142

1

                        rate: 46,

6143

1

},

6144

1

                    deposit_change: Some(DepositChange::Absolute(47)),

6145

1

}),

6146

1

                opening_deposit: 48,

6147

1

},

6148

1

);

6149

1

6150

1

        frame_support::storage::unhashed::put(

6151

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(1),

6152

1

            &OldStream::<AccountId, TimeUnit, StreamPaymentAssetId, Balance> {

6153

1

                source: CHARLIE.into(),

6154

1

                target: ALICE.into(),

6155

1

                config: OldStreamConfig {

6156

1

                    time_unit: TimeUnit::Timestamp,

6157

1

                    asset_id: StreamPaymentAssetId::Native,

6158

1

                    rate: 100,

6159

1

},

6160

1

                deposit: 101,

6161

1

                last_time_updated: 102,

6162

1

                request_nonce: 103,

6163

1

                pending_request: None,

6164

1

                opening_deposit: 104,

6165

1

},

6166

1

);

6167

1

6168

1

        let migration = MigrateStreamPaymentNewConfigFields::<Runtime>(Default::default());

6169

1

        migration.migrate(Default::default());

6170

1

6171

1

        assert_eq!(

6172

1

            pallet_stream_payment::Streams::<Runtime>::get(0).unwrap(),

6173

1

            Stream {

6174

1

                source: ALICE.into(),

6175

1

                target: BOB.into(),

6176

1

                config: StreamConfig {

6177

1

                    time_unit: TimeUnit::Timestamp,

6178

1

                    asset_id: StreamPaymentAssetId::Native,

6179

1

                    rate: 41,

6180

1

                    minimum_request_deadline_delay: 0,

6181

1

                    soft_minimum_deposit: 0,

6182

1

},

6183

1

                deposit: 42,

6184

1

                last_time_updated: 43,

6185

1

                request_nonce: 44,

6186

1

                pending_request: Some(ChangeRequest {

6187

1

                    requester: Party::Source,

6188

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

6189

1

                    new_config: StreamConfig {

6190

1

                        time_unit: TimeUnit::BlockNumber,

6191

1

                        asset_id: StreamPaymentAssetId::Native,

6192

1

                        rate: 46,

6193

1

                        minimum_request_deadline_delay: 0,

6194

1

                        soft_minimum_deposit: 0,

6195

1

},

6196

1

                    deposit_change: Some(DepositChange::Absolute(47)),

6197

1

}),

6198

1

                opening_deposit: 48,

6199

1

6200

1

);

6201

6202

1

        assert_eq!(

6203

1

            pallet_stream_payment::Streams::<Runtime>::get(1).unwrap(),

6204

1

            Stream {

6205

1

                source: CHARLIE.into(),

6206

1

                target: ALICE.into(),

6207

1

                config: StreamConfig {

6208

1

                    time_unit: TimeUnit::Timestamp,

6209

1

                    asset_id: StreamPaymentAssetId::Native,

6210

1

                    rate: 100,

6211

1

                    minimum_request_deadline_delay: 0,

6212

1

                    soft_minimum_deposit: 0,

6213

1

},

6214

1

                deposit: 101,

6215

1

                last_time_updated: 102,

6216

1

                request_nonce: 103,

6217

1

                pending_request: None,

6218

1

                opening_deposit: 104,

6219

1

6220

1

);

6221

1

})

6222

1

6223

6224

#[test]

6225

1

fn test_container_deregister_unassign_data_preserver() {

6226

1

    ExtBuilder::default()

6227

1

        .with_balances(vec![

6228

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6229

1

            (AccountId::from(BOB), 100_000 * UNIT),

6230

1

])

6231

1

        .build()

6232

1

        .execute_with(|| {

6233

            use pallet_data_preservers::{

6234

                AssignerParameterOf, ParaIdsFilter, Profile, ProfileMode, ProviderRequestOf,

6235

};

6236

6237

1

            let profile = Profile {

6238

1

                url: b"test".to_vec().try_into().unwrap(),

6239

1

                para_ids: ParaIdsFilter::AnyParaId,

6240

1

                mode: ProfileMode::Bootnode,

6241

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

6242

1

};

6243

1

6244

1

            let para_id = ParaId::from(1002);

6245

1

            let profile_id = 0u64;

6246

1

6247

1

            assert_ok!(Registrar::register(

6248

1

                origin_of(ALICE.into()),

6249

1

                para_id,

6250

1

                empty_genesis_data(),

6251

1

                None

6252

1

));

6253

6254

1

            assert_ok!(DataPreservers::create_profile(

6255

1

                origin_of(BOB.into()),

6256

1

                profile.clone(),

6257

1

));

6258

6259

            // Start assignment

6260

1

            assert_ok!(DataPreservers::start_assignment(

6261

1

                origin_of(ALICE.into()),

6262

1

                profile_id,

6263

1

                para_id,

6264

1

                AssignerParameterOf::<Runtime>::Free

6265

1

));

6266

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&0u64));

6267

6268

            // Deregister from Registrar

6269

1

            assert_ok!(Registrar::deregister(root_origin(), para_id), ());

6270

6271

            // Check DataPreserver assignment has been cleared

6272

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).is_empty());

6273

1

});

6274

1