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::{tests::common::*, RuntimeOrigin, StreamPaymentAssetId, TimeUnit},

21

    cumulus_primitives_core::{ParaId, Weight},

22

    dp_consensus::runtime_decl_for_tanssi_authority_assignment_api::TanssiAuthorityAssignmentApiV1,

23

    dp_core::well_known_keys,

24

    frame_support::{assert_noop, assert_ok, BoundedVec},

25

    frame_system::ConsumedWeight,

26

    nimbus_primitives::NIMBUS_KEY_ID,

27

    pallet_author_noting_runtime_api::runtime_decl_for_author_noting_api::AuthorNotingApi,

28

    pallet_collator_assignment_runtime_api::runtime_decl_for_collator_assignment_api::CollatorAssignmentApi,

29

    pallet_migrations::Migration,

30

    pallet_registrar_runtime_api::{

31

        runtime_decl_for_registrar_api::RegistrarApi, ContainerChainGenesisData,

32

},

33

    parity_scale_codec::Encode,

34

    sp_consensus_aura::AURA_ENGINE_ID,

35

    sp_core::Get,

36

    sp_runtime::{

37

        traits::{BadOrigin, BlakeTwo256, Dispatchable, OpaqueKeys},

38

        DigestItem,

39

},

40

    sp_std::vec,

41

    tanssi_runtime_common::migrations::MigrateServicesPaymentAddCollatorAssignmentCredits,

42

    test_relay_sproof_builder::{HeaderAs, ParaHeaderSproofBuilder, ParaHeaderSproofBuilderItem},

43

    tp_traits::{ContainerChainBlockInfo, SlotFrequency},

44

};

45

46

20

fn set_dummy_boot_node(para_manager: RuntimeOrigin, para_id: ParaId) {

47

    use {

48

        crate::{PreserversAssignementPaymentExtra, PreserversAssignementPaymentRequest},

49

        pallet_data_preservers::{ParaIdsFilter, Profile, ProfileMode},

50

};

51

52

20

    let profile = Profile {

53

20

        url:

54

20

            b"/ip4/127.0.0.1/tcp/33049/ws/p2p/12D3KooWHVMhQDHBpj9vQmssgyfspYecgV6e3hH1dQVDUkUbCYC9"

55

20

                .to_vec()

56

20

                .try_into()

57

20

                .expect("to fit in BoundedVec"),

58

20

        para_ids: ParaIdsFilter::AnyParaId,

59

20

        mode: ProfileMode::Bootnode,

60

20

        assignment_request: PreserversAssignementPaymentRequest::Free,

61

20

};

62

20

63

20

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

64

20

    let profile_owner = AccountId::new([1u8; 32]);

65

20

    DataPreservers::force_create_profile(RuntimeOrigin::root(), profile, profile_owner)

66

20

        .expect("profile create to succeed");

67

20

68

20

    DataPreservers::start_assignment(

69

20

        para_manager,

70

20

        profile_id,

71

20

        para_id,

72

20

        PreserversAssignementPaymentExtra::Free,

73

20

74

20

    .expect("assignement to work");

75

20

76

20

    assert!(

77

20

        pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&profile_id),

78

        "profile should be correctly assigned"

79

);

80

20

81

82

#[test]

83

1

fn genesis_balances() {

84

1

    ExtBuilder::default()

85

1

        .with_balances(vec![

86

1

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

87

1

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

88

1

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

89

1

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

90

1

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

91

1

])

92

1

        .with_collators(vec![

93

1

            // Remove ALICE and BOB from collators

94

1

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

95

1

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

96

1

])

97

1

        .build()

98

1

        .execute_with(|| {

99

1

            assert_eq!(

100

1

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

101

1

                210_000 * UNIT,

102

1

);

103

1

            assert_eq!(

104

1

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

105

1

                100_000 * UNIT,

106

1

);

107

1

});

108

1

109

110

#[test]

111

1

fn genesis_para_registrar() {

112

1

    ExtBuilder::default()

113

1

        .with_empty_parachains(vec![1001, 1002])

114

1

        .build()

115

1

        .execute_with(|| {

116

1

            assert_eq!(

117

1

                Registrar::registered_para_ids(),

118

1

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

119

1

);

120

1

});

121

1

122

123

#[test]

124

1

fn genesis_para_registrar_deregister() {

125

1

    ExtBuilder::default()

126

1

        .with_empty_parachains(vec![1001, 1002])

127

1

        .build()

128

1

        .execute_with(|| {

129

1

            assert_eq!(

130

1

                Registrar::registered_para_ids(),

131

1

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

132

1

);

133

134

1

            run_to_block(2);

135

1

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

136

137

            // Pending

138

1

            assert_eq!(

139

1

                Registrar::pending_registered_para_ids(),

140

1

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

141

1

);

142

143

1

            run_to_session(1);

144

1

            assert_eq!(

145

1

                Registrar::pending_registered_para_ids(),

146

1

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

147

1

);

148

1

            assert_eq!(

149

1

                Registrar::registered_para_ids(),

150

1

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

151

1

);

152

153

1

            run_to_session(2);

154

1

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

155

1

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

156

1

});

157

1

158

159

#[test]

160

1

fn genesis_para_registrar_runtime_api() {

161

1

    ExtBuilder::default()

162

1

        .with_empty_parachains(vec![1001, 1002])

163

1

        .build()

164

1

        .execute_with(|| {

165

1

            assert_eq!(

166

1

                Registrar::registered_para_ids(),

167

1

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

168

1

);

169

1

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

170

171

1

            run_to_block(2);

172

1

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

173

1

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

174

175

1

            run_to_session(1);

176

1

            assert_eq!(

177

1

                Registrar::registered_para_ids(),

178

1

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

179

1

);

180

1

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

181

182

1

            run_to_session(2);

183

1

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

184

1

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

185

1

});

186

1

187

188

#[test]

189

1

fn genesis_para_registrar_container_chain_genesis_data_runtime_api() {

190

1

    let genesis_data_1001 = empty_genesis_data();

191

1

    let genesis_data_1002 = ContainerChainGenesisData {

192

1

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

193

1

        name: Default::default(),

194

1

        id: Default::default(),

195

1

        fork_id: Default::default(),

196

1

        extensions: vec![],

197

1

        properties: Default::default(),

198

1

};

199

1

    ExtBuilder::default()

200

1

        .with_para_ids(vec![

201

1

            ParaRegistrationParams {

202

1

                para_id: 1001,

203

1

                genesis_data: genesis_data_1001.clone(),

204

1

                block_production_credits: u32::MAX,

205

1

                collator_assignment_credits: u32::MAX,

206

1

                parathread_params: None,

207

1

            },ParaRegistrationParams {

208

1

                para_id: 1002,

209

1

                genesis_data: genesis_data_1002.clone(),

210

1

                block_production_credits: u32::MAX,

211

1

                collator_assignment_credits: u32::MAX,

212

1

                parathread_params: None,

213

1

            },        ])

214

1

        .build()

215

1

        .execute_with(|| {

216

1

            assert_eq!(

217

1

                Registrar::registered_para_ids(),

218

1

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

219

1

);

220

1

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

221

222

1

            assert_eq!(

223

1

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

224

1

                Some(&genesis_data_1001)

225

1

);

226

1

            assert_eq!(

227

1

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

228

1

                Some(&genesis_data_1002)

229

1

);

230

1

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

231

232

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

233

            // with id 100

234

            // TODO: where is that 100 defined?

235

1

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

236

237

1

            run_to_block(2);

238

1

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

239

240

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

241

242

1

            let genesis_data_1003 = ContainerChainGenesisData {

243

1

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

244

1

                name: Default::default(),

245

1

                id: Default::default(),

246

1

                fork_id: Default::default(),

247

1

                extensions: vec![],

248

1

                properties: Default::default(),

249

1

};

250

1

            assert_ok!(

251

1

                Registrar::register(

252

1

                    origin_of(ALICE.into()),

253

1

                    1003.into(),

254

1

                    genesis_data_1003.clone(),

255

1

                    None

256

1

),

257

1

()

258

1

);

259

260

            // Registered container chains are inserted immediately

261

1

            assert_eq!(

262

1

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

263

1

                Some(&genesis_data_1003)

264

1

);

265

266

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

267

1

            run_to_session(2u32);

268

1

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

269

1

});

270

1

271

272

#[test]

273

1

fn test_author_collation_aura() {

274

1

    ExtBuilder::default()

275

1

        .with_empty_parachains(vec![1001, 1002])

276

1

        .build()

277

1

        .execute_with(|| {

278

1

            run_to_block(5);

279

1

            // Assert current slot gets updated

280

1

            assert_eq!(current_slot(), 4u64);

281

            // slot 4, alice

282

1

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

283

284

1

            run_to_block(6);

285

1

286

1

            assert_eq!(current_slot(), 5u64);

287

            // slot 5, bob

288

1

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

289

1

});

290

1

291

292

#[test]

293

1

fn test_author_collation_aura_change_of_authorities_on_session() {

294

1

    ExtBuilder::default()

295

1

        .with_balances(vec![

296

1

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

297

1

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

298

1

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

299

1

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

300

1

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

301

1

])

302

1

        .with_empty_parachains(vec![1001, 1002])

303

1

        .build()

304

1

        .execute_with(|| {

305

1

            run_to_block(2);

306

1

            // Assert current slot gets updated

307

1

            assert_eq!(current_slot(), 1u64);

308

1

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

309

310

            // We change invulnerables

311

            // We first need to set the keys

312

1

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

313

1

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

314

1

315

1

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

316

1

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

317

1

318

1

            // Set CHARLIE and DAVE keys

319

1

            assert_ok!(Session::set_keys(

320

1

                origin_of(CHARLIE.into()),

321

1

                crate::SessionKeys {

322

1

                    nimbus: charlie_id.clone(),

323

1

},

324

1

                vec![]

325

1

));

326

1

            assert_ok!(Session::set_keys(

327

1

                origin_of(DAVE.into()),

328

1

                crate::SessionKeys {

329

1

                    nimbus: dave_id.clone(),

330

1

},

331

1

                vec![]

332

1

));

333

334

            // Change invulnerables

335

1

            assert_ok!(Invulnerables::remove_invulnerable(

336

1

                root_origin(),

337

1

                ALICE.into()

338

1

));

339

1

            assert_ok!(Invulnerables::remove_invulnerable(

340

1

                root_origin(),

341

1

                BOB.into()

342

1

));

343

1

            assert_ok!(Invulnerables::add_invulnerable(

344

1

                root_origin(),

345

1

                CHARLIE.into()

346

1

));

347

1

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

348

349

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

350

1

            run_to_session(1u32);

351

1

            let author = get_orchestrator_current_author().unwrap();

352

1

353

1

            assert_eq!(current_author(), author);

354

1

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

355

356

            // Invulnerables should have triggered on new session authorities change

357

1

            run_to_session(2u32);

358

1

            let author_after_changes = get_orchestrator_current_author().unwrap();

359

1

360

1

            assert_eq!(current_author(), author_after_changes);

361

1

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

362

1

});

363

1

364

365

#[test]

366

1

fn test_author_collation_aura_add_assigned_to_paras() {

367

1

    ExtBuilder::default()

368

1

        .with_balances(vec![

369

1

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

370

1

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

371

1

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

372

1

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

373

1

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

374

1

])

375

1

        .with_empty_parachains(vec![1001, 1002])

376

1

        .build()

377

1

        .execute_with(|| {

378

1

            run_to_block(2);

379

1

            // Assert current slot gets updated

380

1

            assert_eq!(current_slot(), 1u64);

381

1

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

382

383

            // We change invulnerables

384

            // We first need to set the keys

385

1

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

386

1

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

387

1

388

1

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

389

1

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

390

1

391

1

            // Set CHARLIE and DAVE keys

392

1

            assert_ok!(Session::set_keys(

393

1

                origin_of(CHARLIE.into()),

394

1

                crate::SessionKeys { nimbus: charlie_id },

395

1

                vec![]

396

1

));

397

1

            assert_ok!(Session::set_keys(

398

1

                origin_of(DAVE.into()),

399

1

                crate::SessionKeys { nimbus: dave_id },

400

1

                vec![]

401

1

));

402

403

            // Add new invulnerables

404

1

            assert_ok!(Invulnerables::add_invulnerable(

405

1

                root_origin(),

406

1

                CHARLIE.into()

407

1

));

408

1

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

409

410

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

411

1

            run_to_session(1u32);

412

1

            let author = get_orchestrator_current_author().unwrap();

413

1

414

1

            assert_eq!(current_author(), author);

415

1

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

416

417

            // Invulnerables should have triggered on new session authorities change

418

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

419

1

            run_to_session(2u32);

420

1

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

421

1

            let assignment = CollatorAssignment::collator_container_chain();

422

1

            assert_eq!(

423

1

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

424

1

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

425

1

);

426

1

});

427

1

428

429

#[test]

430

1

fn test_authors_without_paras() {

431

1

    ExtBuilder::default()

432

1

        .with_balances(vec![

433

1

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

434

1

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

435

1

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

436

1

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

437

1

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

438

1

])

439

1

        .with_collators(vec![

440

1

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

441

1

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

442

1

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

443

1

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

444

1

])

445

1

        .build()

446

1

        .execute_with(|| {

447

1

            run_to_block(2);

448

1

            // Assert current slot gets updated

449

1

            assert_eq!(current_slot(), 1u64);

450

1

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

451

452

            // Only Alice and Bob collate for our chain

453

1

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

454

1

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

455

1

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

456

1

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

457

1

458

1

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

459

1

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

460

461

            // Set moondance collators to min 2 max 5

462

1

            assert_ok!(

463

1

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

464

1

()

465

1

);

466

1

            assert_ok!(

467

1

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

468

1

()

469

1

);

470

471

1

            run_to_session(2);

472

1

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

473

1

});

474

1

475

476

#[test]

477

1

fn test_authors_paras_inserted_a_posteriori() {

478

1

    ExtBuilder::default()

479

1

        .with_balances(vec![

480

1

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

481

1

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

482

1

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

483

1

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

484

1

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

485

1

])

486

1

        .with_collators(vec![

487

1

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

488

1

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

489

1

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

490

1

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

491

1

])

492

1

        .build()

493

1

        .execute_with(|| {

494

1

            run_to_block(2);

495

1

            // Assert current slot gets updated

496

1

            assert_eq!(current_slot(), 1u64);

497

1

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

498

499

            // Alice and Bob collate in our chain

500

1

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

501

1

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

502

1

503

1

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

504

505

1

            assert_ok!(Registrar::register(

506

1

                origin_of(ALICE.into()),

507

1

                1001.into(),

508

1

                empty_genesis_data(),

509

1

                None

510

1

));

511

1

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

512

1

            assert_ok!(Registrar::mark_valid_for_collating(

513

1

                root_origin(),

514

1

                1001.into()

515

1

));

516

1

            assert_ok!(ServicesPayment::purchase_credits(

517

1

                origin_of(ALICE.into()),

518

1

                1001.into(),

519

1

                block_credits_to_required_balance(1000, 1001.into())

520

1

));

521

1

            assert_ok!(Registrar::register(

522

1

                origin_of(ALICE.into()),

523

1

                1002.into(),

524

1

                empty_genesis_data(),

525

1

                None

526

1

));

527

1

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

528

1

            assert_ok!(Registrar::mark_valid_for_collating(

529

1

                root_origin(),

530

1

                1002.into()

531

1

));

532

1

            assert_ok!(ServicesPayment::purchase_credits(

533

1

                origin_of(ALICE.into()),

534

1

                1002.into(),

535

1

                block_credits_to_required_balance(1000, 1002.into())

536

1

));

537

538

            // Assignment should happen after 2 sessions

539

1

            run_to_session(1u32);

540

1

            let assignment = CollatorAssignment::collator_container_chain();

541

1

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

542

1

            run_to_session(2u32);

543

1

544

1

            // Charlie and Dave should be assigned to para 1001

545

1

            let assignment = CollatorAssignment::collator_container_chain();

546

1

            assert_eq!(

547

1

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

548

1

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

549

1

);

550

1

});

551

1

552

553

#[test]

554

1

fn test_authors_paras_inserted_a_posteriori_with_collators_already_assigned() {

555

1

    ExtBuilder::default()

556

1

        .with_balances(vec![

557

1

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

558

1

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

559

1

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

560

1

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

561

1

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

562

1

])

563

1

        .with_collators(vec![

564

1

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

565

1

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

566

1

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

567

1

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

568

1

])

569

1

        .with_config(pallet_configuration::HostConfiguration {

570

1

            max_collators: 100,

571

1

            min_orchestrator_collators: 2,

572

1

            max_orchestrator_collators: 5,

573

1

            collators_per_container: 2,

574

1

            full_rotation_period: 0,

575

1

            ..Default::default()

576

1

})

577

1

        .build()

578

1

        .execute_with(|| {

579

1

            run_to_block(2);

580

1

            // Assert current slot gets updated

581

1

            assert_eq!(current_slot(), 1u64);

582

1

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

583

584

            // Alice and Bob collate in our chain

585

1

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

586

1

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

587

1

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

588

1

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

589

1

590

1

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

591

592

1

            assert_ok!(Registrar::register(

593

1

                origin_of(ALICE.into()),

594

1

                1001.into(),

595

1

                empty_genesis_data(),

596

1

                None

597

1

));

598

1

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

599

1

            assert_ok!(Registrar::mark_valid_for_collating(

600

1

                root_origin(),

601

1

                1001.into()

602

1

));

603

1

            assert_ok!(ServicesPayment::purchase_credits(

604

1

                origin_of(ALICE.into()),

605

1

                1001.into(),

606

1

                block_credits_to_required_balance(1000, 1001.into())

607

1

));

608

609

            // Assignment should happen after 2 sessions

610

1

            run_to_session(1u32);

611

1

            let assignment = CollatorAssignment::collator_container_chain();

612

1

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

613

1

            run_to_session(2u32);

614

1

615

1

            // Charlie and Dave are now assigned to para 1001

616

1

            let assignment = CollatorAssignment::collator_container_chain();

617

1

            assert_eq!(

618

1

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

619

1

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

620

1

);

621

1

            assert_eq!(

622

1

                assignment.orchestrator_chain,

623

1

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

624

1

);

625

1

});

626

1

627

628

#[test]

629

1

fn test_paras_registered_but_zero_credits() {

630

1

    ExtBuilder::default()

631

1

        .with_balances(vec![

632

1

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

633

1

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

634

1

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

635

1

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

636

1

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

637

1

])

638

1

        .with_collators(vec![

639

1

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

640

1

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

641

1

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

642

1

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

643

1

])

644

1

        .build()

645

1

        .execute_with(|| {

646

1

            run_to_block(2);

647

1

            // Assert current slot gets updated

648

1

            assert_eq!(current_slot(), 1u64);

649

1

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

650

651

            // Alice and Bob collate in our chain

652

1

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

653

1

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

654

1

655

1

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

656

657

1

            assert_ok!(Registrar::register(

658

1

                origin_of(ALICE.into()),

659

1

                1001.into(),

660

1

                empty_genesis_data(),

661

1

                None

662

1

));

663

1

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

664

1

            assert_ok!(Registrar::mark_valid_for_collating(

665

1

                root_origin(),

666

1

                1001.into()

667

1

));

668

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

669

1

            assert_ok!(ServicesPayment::set_block_production_credits(

670

1

                root_origin(),

671

1

                1001.into(),

672

1

673

1

));

674

675

            // Assignment should happen after 2 sessions

676

1

            run_to_session(1u32);

677

1

            let assignment = CollatorAssignment::collator_container_chain();

678

1

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

679

1

            run_to_session(2u32);

680

1

681

1

            // Nobody should be assigned to para 1001

682

1

            let assignment = CollatorAssignment::collator_container_chain();

683

1

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

684

1

});

685

1

686

687

#[test]

688

1

fn test_paras_registered_but_not_enough_credits() {

689

1

    ExtBuilder::default()

690

1

        .with_balances(vec![

691

1

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

692

1

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

693

1

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

694

1

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

695

1

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

696

1

])

697

1

        .with_collators(vec![

698

1

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

699

1

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

700

1

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

701

1

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

702

1

])

703

1

        .build()

704

1

        .execute_with(|| {

705

1

            run_to_block(2);

706

1

            // Assert current slot gets updated

707

1

            assert_eq!(current_slot(), 1u64);

708

1

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

709

710

            // Alice and Bob collate in our chain

711

1

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

712

1

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

713

1

714

1

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

715

716

1

            assert_ok!(Registrar::register(

717

1

                origin_of(ALICE.into()),

718

1

                1001.into(),

719

1

                empty_genesis_data(),

720

1

                None

721

1

));

722

1

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

723

1

            assert_ok!(Registrar::mark_valid_for_collating(

724

1

                root_origin(),

725

1

                1001.into()

726

1

));

727

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

728

1

            assert_ok!(ServicesPayment::set_block_production_credits(

729

1

                root_origin(),

730

1

                1001.into(),

731

1

732

1

));

733

            // Purchase 1 credit less that what is needed

734

1

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

735

1

            assert_ok!(ServicesPayment::set_block_production_credits(

736

1

                root_origin(),

737

1

                1001.into(),

738

1

                credits_1001

739

1

));

740

741

            // Assignment should happen after 2 sessions

742

1

            run_to_session(1u32);

743

1

            let assignment = CollatorAssignment::collator_container_chain();

744

1

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

745

1

            run_to_session(2u32);

746

1

            // Nobody should be assigned to para 1001

747

1

            let assignment = CollatorAssignment::collator_container_chain();

748

1

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

749

750

            // Now purchase the missing block credit

751

1

            assert_ok!(ServicesPayment::set_block_production_credits(

752

1

                root_origin(),

753

1

                1001.into(),

754

1

                credits_1001 + 1

755

1

));

756

757

1

            run_to_session(4u32);

758

1

            // Charlie and Dave should be assigned to para 1001

759

1

            let assignment = CollatorAssignment::collator_container_chain();

760

1

            assert_eq!(

761

1

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

762

1

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

763

1

);

764

1

});

765

1

766

767

#[test]

768

1

fn test_paras_registered_but_only_credits_for_1_session() {

769

1

    ExtBuilder::default()

770

1

        .with_balances(vec![

771

1

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

772

1

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

773

1

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

774

1

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

775

1

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

776

1

])

777

1

        .with_collators(vec![

778

1

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

779

1

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

780

1

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

781

1

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

782

1

])

783

1

        .build()

784

1

        .execute_with(|| {

785

1

            run_to_block(2);

786

1

            // Assert current slot gets updated

787

1

            assert_eq!(current_slot(), 1u64);

788

1

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

789

790

            // Alice and Bob collate in our chain

791

1

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

792

1

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

793

1

794

1

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

795

796

1

            assert_ok!(Registrar::register(

797

1

                origin_of(ALICE.into()),

798

1

                1001.into(),

799

1

                empty_genesis_data(),

800

1

                None

801

1

));

802

1

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

803

1

            assert_ok!(Registrar::mark_valid_for_collating(

804

1

                root_origin(),

805

1

                1001.into()

806

1

));

807

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

808

1

            assert_ok!(ServicesPayment::set_block_production_credits(

809

1

                root_origin(),

810

1

                1001.into(),

811

1

812

1

));

813

            // Purchase only enough credits for 1 session

814

1

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

815

1

            assert_ok!(ServicesPayment::set_block_production_credits(

816

1

                root_origin(),

817

1

                1001.into(),

818

1

                credits_1001

819

1

));

820

821

            // Assignment should happen after 2 sessions

822

1

            run_to_session(1u32);

823

1

            let assignment = CollatorAssignment::collator_container_chain();

824

1

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

825

1

            run_to_session(2u32);

826

1

            // Charlie and Dave should be assigned to para 1001

827

1

            let assignment = CollatorAssignment::collator_container_chain();

828

1

            assert_eq!(

829

1

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

830

1

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

831

1

);

832

833

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

834

1

            run_block();

835

1

            let credits =

836

1

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

837

1

                    .unwrap_or_default();

838

1

            assert_eq!(credits, credits_1001);

839

840

            // Simulate block inclusion from container chain 1001

841

1

            let mut sproof = ParaHeaderSproofBuilder::default();

842

1

            let slot: u64 = 5;

843

1

            let s = ParaHeaderSproofBuilderItem {

844

1

                para_id: 1001.into(),

845

1

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

846

1

                    parent_hash: Default::default(),

847

1

                    number: 1,

848

1

                    state_root: Default::default(),

849

1

                    extrinsics_root: Default::default(),

850

1

                    digest: sp_runtime::generic::Digest {

851

1

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

852

1

},

853

1

}),

854

1

};

855

1

            sproof.items.push(s);

856

1

            set_author_noting_inherent_data(sproof);

857

1

858

1

            run_block();

859

1

            let credits =

860

1

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

861

1

                    .unwrap_or_default();

862

1

            assert_eq!(credits, credits_1001 - 1);

863

864

1

            run_to_session(4u32);

865

1

            // Nobody should be assigned to para 1001

866

1

            let assignment = CollatorAssignment::collator_container_chain();

867

1

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

868

869

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

870

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

871

1

            let credits =

872

1

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

873

1

                    .unwrap_or_default();

874

1

            assert_eq!(credits, credits_1001 - 1);

875

1

});

876

1

877

878

#[test]

879

1

fn test_parachains_deregister_collators_re_assigned() {

880

1

    ExtBuilder::default()

881

1

        .with_balances(vec![

882

1

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

883

1

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

884

1

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

885

1

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

886

1

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

887

1

])

888

1

        .with_collators(vec![

889

1

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

890

1

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

891

1

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

892

1

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

893

1

])

894

1

        .with_empty_parachains(vec![1001, 1002])

895

1

        .build()

896

1

        .execute_with(|| {

897

1

            run_to_block(2);

898

1

            // Assert current slot gets updated

899

1

            assert_eq!(current_slot(), 1u64);

900

1

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

901

902

            // Alice and Bob are authorities

903

1

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

904

1

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

905

1

906

1

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

907

908

            // Charlie and Dave to 1001

909

1

            let assignment = CollatorAssignment::collator_container_chain();

910

1

            assert_eq!(

911

1

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

912

1

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

913

1

);

914

915

1

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

916

917

            // Assignment should happen after 2 sessions

918

1

            run_to_session(1u32);

919

1

920

1

            let assignment = CollatorAssignment::collator_container_chain();

921

1

            assert_eq!(

922

1

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

923

1

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

924

1

);

925

926

1

            run_to_session(2u32);

927

1

928

1

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

929

1

            let assignment = CollatorAssignment::collator_container_chain();

930

1

            assert_eq!(

931

1

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

932

1

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

933

1

);

934

1

});

935

1

936

937

#[test]

938

1

fn test_parachains_deregister_collators_config_change_reassigned() {

939

1

    ExtBuilder::default()

940

1

        .with_balances(vec![

941

1

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

942

1

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

943

1

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

944

1

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

945

1

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

946

1

])

947

1

        .with_collators(vec![

948

1

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

949

1

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

950

1

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

951

1

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

952

1

])

953

1

        .with_empty_parachains(vec![1001, 1002])

954

1

        .build()

955

1

        .execute_with(|| {

956

1

            run_to_block(2);

957

1

            // Assert current slot gets updated

958

1

            assert_eq!(current_slot(), 1u64);

959

1

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

960

961

            // Alice and Bob are authorities

962

1

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

963

1

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

964

1

965

1

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

966

967

            // Set orchestrator collators to 1

968

1

            assert_ok!(

969

1

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

970

1

()

971

1

);

972

973

            // Set container chain collators to 3

974

1

            assert_ok!(

975

1

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

976

1

()

977

1

);

978

979

            // Charlie and Dave to 1001

980

1

            let assignment = CollatorAssignment::collator_container_chain();

981

1

            assert_eq!(

982

1

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

983

1

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

984

1

);

985

986

            // Assignment should happen after 2 sessions

987

1

            run_to_session(1u32);

988

1

989

1

            let assignment = CollatorAssignment::collator_container_chain();

990

1

            assert_eq!(

991

1

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

992

1

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

993

1

);

994

995

1

            run_to_session(2u32);

996

1

997

1

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

998

1

            let assignment = CollatorAssignment::collator_container_chain();

999

1

            assert_eq!(

1000

1

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

1001

1

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

1002

1

);

1003

1004

1

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

1005

1

});

1006

1

1007

1008

#[test]

1009

1

fn test_orchestrator_collators_with_non_sufficient_collators() {

1010

1

    ExtBuilder::default()

1011

1

        .with_balances(vec![

1012

1

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

1013

1

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

1014

1

])

1015

1

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

1016

1

        .with_empty_parachains(vec![1001, 1002])

1017

1

        .build()

1018

1

        .execute_with(|| {

1019

1

            run_to_block(2);

1020

1

            // Assert current slot gets updated

1021

1

            assert_eq!(current_slot(), 1u64);

1022

1

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

1023

1024

            // Alice and Bob are authorities

1025

1

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

1026

1

1027

1

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

1028

1

});

1029

1

1030

1031

#[test]

1032

1

fn test_configuration_on_session_change() {

1033

1

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

1034

1

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

1035

1

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

1036

1

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

1037

1038

1

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

1039

1

        run_to_session(1u32);

1040

1

1041

1

        assert_ok!(

1042

1

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

1043

1

()

1044

1

);

1045

1

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

1046

1

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

1047

1

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

1048

1049

1

        run_to_session(2u32);

1050

1

        assert_ok!(

1051

1

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

1052

1

()

1053

1

);

1054

1

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

1055

1

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

1056

1

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

1057

1058

1

        run_to_session(3u32);

1059

1

1060

1

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

1061

1

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

1062

1

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

1063

1064

1

        run_to_session(4u32);

1065

1

1066

1

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

1067

1

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

1068

1

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

1069

1

});

1070

1

1071

1072

#[test]

1073

1

fn test_author_collation_aura_add_assigned_to_paras_runtime_api() {

1074

1

    ExtBuilder::default()

1075

1

        .with_balances(vec![

1076

1

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

1077

1

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

1078

1

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

1079

1

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

1080

1

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

1081

1

])

1082

1

        .with_empty_parachains(vec![1001, 1002])

1083

1

        .build()

1084

1

        .execute_with(|| {

1085

1

            run_to_block(2);

1086

1

            // Assert current slot gets updated

1087

1

            assert_eq!(current_slot(), 1u64);

1088

1

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

1089

1

            assert_eq!(

1090

1

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

1091

1

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

1092

1

);

1093

1

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

1094

1

            assert_eq!(

1095

1

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

1096

1

                Some(100.into())

1097

1

);

1098

1

            assert_eq!(

1099

1

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

1100

1

                Some(100.into())

1101

1

);

1102

1

            assert_eq!(

1103

1

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

1104

1

                None

1105

1

);

1106

1

            assert_eq!(

1107

1

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

1108

1

                None

1109

1

);

1110

1111

            // We change invulnerables

1112

            // We first need to set the keys

1113

1

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

1114

1

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

1115

1

1116

1

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

1117

1

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

1118

1

1119

1

            // Set CHARLIE and DAVE keys

1120

1

            assert_ok!(Session::set_keys(

1121

1

                origin_of(CHARLIE.into()),

1122

1

                crate::SessionKeys { nimbus: charlie_id },

1123

1

                vec![]

1124

1

));

1125

1

            assert_ok!(Session::set_keys(

1126

1

                origin_of(DAVE.into()),

1127

1

                crate::SessionKeys { nimbus: dave_id },

1128

1

                vec![]

1129

1

));

1130

1131

            // Set new invulnerables

1132

1

            assert_ok!(Invulnerables::add_invulnerable(

1133

1

                root_origin(),

1134

1

                CHARLIE.into()

1135

1

));

1136

1

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

1137

1138

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

1139

1

            run_to_session(1u32);

1140

1

            let author = get_orchestrator_current_author().unwrap();

1141

1

1142

1

            assert_eq!(current_author(), author);

1143

1

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

1144

1

            assert_eq!(

1145

1

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

1146

1

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

1147

1

);

1148

1

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

1149

1

            assert_eq!(

1150

1

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

1151

1

                None

1152

1

);

1153

1

            assert_eq!(

1154

1

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

1155

1

                Some(1001.into())

1156

1

);

1157

1158

            // Invulnerables should have triggered on new session authorities change

1159

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

1160

1

            run_to_session(2u32);

1161

1

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

1162

1

            let assignment = CollatorAssignment::collator_container_chain();

1163

1

            assert_eq!(

1164

1

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

1165

1

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

1166

1

);

1167

1168

1

            assert_eq!(

1169

1

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

1170

1

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

1171

1

);

1172

1

            assert_eq!(

1173

1

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

1174

1

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

1175

1

);

1176

1

            assert_eq!(

1177

1

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

1178

1

                Some(1001.into())

1179

1

);

1180

1

            assert_eq!(

1181

1

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

1182

1

                Some(1001.into())

1183

1

);

1184

1185

            // Remove BOB

1186

1

            assert_ok!(Invulnerables::remove_invulnerable(

1187

1

                root_origin(),

1188

1

                BOB.into()

1189

1

));

1190

1191

1

            run_to_session(3u32);

1192

1

            assert_eq!(

1193

1

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

1194

1

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

1195

1

);

1196

1

            assert_eq!(

1197

1

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

1198

1

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

1199

1

);

1200

1

            assert_eq!(

1201

1

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

1202

1

                Some(100.into())

1203

1

);

1204

1

            assert_eq!(

1205

1

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

1206

1

                None

1207

1

);

1208

1209

1

            run_to_session(4u32);

1210

1

            assert_eq!(

1211

1

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

1212

1

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

1213

1

);

1214

1

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

1215

1

            assert_eq!(

1216

1

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

1217

1

                None

1218

1

);

1219

1

            assert_eq!(

1220

1

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

1221

1

                None

1222

1

);

1223

1

});

1224

1

1225

1226

#[test]

1227

1

fn test_consensus_runtime_api() {

1228

1

    ExtBuilder::default()

1229

1

        .with_balances(vec![

1230

1

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

1231

1

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

1232

1

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

1233

1

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

1234

1

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

1235

1

])

1236

1

        .with_empty_parachains(vec![1001, 1002])

1237

1

        .build()

1238

1

        .execute_with(|| {

1239

1

            run_to_block(2);

1240

1

1241

1

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

1242

1

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

1243

1

1244

1

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

1245

1

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

1246

1

1247

1

            assert_eq!(

1248

1

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

1249

1

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

1250

1

);

1251

1

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

1252

1

            assert_eq!(

1253

1

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

1254

1

                Some(100.into())

1255

1

);

1256

1

            assert_eq!(

1257

1

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

1258

1

                Some(100.into())

1259

1

);

1260

1

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

1261

1

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

1262

1263

            // Set CHARLIE and DAVE keys

1264

1

            assert_ok!(Session::set_keys(

1265

1

                origin_of(CHARLIE.into()),

1266

1

                crate::SessionKeys {

1267

1

                    nimbus: charlie_id.clone(),

1268

1

},

1269

1

                vec![]

1270

1

));

1271

1

            assert_ok!(Session::set_keys(

1272

1

                origin_of(DAVE.into()),

1273

1

                crate::SessionKeys {

1274

1

                    nimbus: dave_id.clone(),

1275

1

},

1276

1

                vec![]

1277

1

));

1278

1279

            // Set new invulnerables

1280

1

            assert_ok!(Invulnerables::add_invulnerable(

1281

1

                root_origin(),

1282

1

                CHARLIE.into()

1283

1

));

1284

1

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

1285

1286

1

            run_to_session(2u32);

1287

1

            assert_eq!(

1288

1

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

1289

1

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

1290

1

);

1291

1

            assert_eq!(

1292

1

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

1293

1

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

1294

1

);

1295

1

            assert_eq!(

1296

1

                Runtime::check_para_id_assignment(alice_id),

1297

1

                Some(100.into())

1298

1

);

1299

1

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

1300

1

            assert_eq!(

1301

1

                Runtime::check_para_id_assignment(charlie_id),

1302

1

                Some(1001.into())

1303

1

);

1304

1

            assert_eq!(

1305

1

                Runtime::check_para_id_assignment(dave_id),

1306

1

                Some(1001.into())

1307

1

);

1308

1

});

1309

1

1310

1311

#[test]

1312

1

fn test_consensus_runtime_api_session_changes() {

1313

1

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

1314

1

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

1315

1

    // if we can predict correctly

1316

1

    ExtBuilder::default()

1317

1

        .with_balances(vec![

1318

1

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

1319

1

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

1320

1

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

1321

1

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

1322

1

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

1323

1

])

1324

1

        .with_empty_parachains(vec![1001, 1002])

1325

1

        .build()

1326

1

        .execute_with(|| {

1327

1

            run_to_block(2);

1328

1

1329

1

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

1330

1

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

1331

1

1332

1

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

1333

1

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

1334

1

1335

1

            assert_eq!(

1336

1

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

1337

1

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

1338

1

);

1339

1

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

1340

1

            assert_eq!(

1341

1

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

1342

1

                Some(100.into())

1343

1

);

1344

1

            assert_eq!(

1345

1

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

1346

1

                Some(100.into())

1347

1

);

1348

1

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

1349

1

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

1350

1351

            // Set CHARLIE and DAVE keys

1352

1

            assert_ok!(Session::set_keys(

1353

1

                origin_of(CHARLIE.into()),

1354

1

                crate::SessionKeys {

1355

1

                    nimbus: charlie_id.clone(),

1356

1

},

1357

1

                vec![]

1358

1

));

1359

1

            assert_ok!(Session::set_keys(

1360

1

                origin_of(DAVE.into()),

1361

1

                crate::SessionKeys {

1362

1

                    nimbus: dave_id.clone(),

1363

1

},

1364

1

                vec![]

1365

1

));

1366

1367

            // Set new invulnerables

1368

1

            assert_ok!(Invulnerables::add_invulnerable(

1369

1

                root_origin(),

1370

1

                CHARLIE.into()

1371

1

));

1372

1

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

1373

1374

1

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

1375

1

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

1376

1

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

1377

1

            // edge of a session change

1378

1

            run_to_block(session_two_edge - 2);

1379

1

1380

1

            assert_eq!(

1381

1

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

1382

1

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

1383

1

);

1384

1

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

1385

1

            assert_eq!(

1386

1

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

1387

1

                Some(100.into())

1388

1

);

1389

1

            assert_eq!(

1390

1

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

1391

1

                Some(100.into())

1392

1

);

1393

1

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

1394

1

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

1395

1396

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

1397

            // authorities of the next block!

1398

1

            run_to_block(session_two_edge - 1);

1399

1

            assert_eq!(

1400

1

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

1401

1

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

1402

1

);

1403

1

            assert_eq!(

1404

1

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

1405

1

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

1406

1

);

1407

1

            assert_eq!(

1408

1

                Runtime::check_para_id_assignment(alice_id),

1409

1

                Some(100.into())

1410

1

);

1411

1

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

1412

1

            assert_eq!(

1413

1

                Runtime::check_para_id_assignment(charlie_id),

1414

1

                Some(1001.into())

1415

1

);

1416

1

            assert_eq!(

1417

1

                Runtime::check_para_id_assignment(dave_id),

1418

1

                Some(1001.into())

1419

1

);

1420

1

});

1421

1

1422

1423

#[test]

1424

1

fn test_consensus_runtime_api_next_session() {

1425

1

    ExtBuilder::default()

1426

1

        .with_balances(vec![

1427

1

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

1428

1

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

1429

1

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

1430

1

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

1431

1

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

1432

1

])

1433

1

        .with_empty_parachains(vec![1001, 1002])

1434

1

        .build()

1435

1

        .execute_with(|| {

1436

1

            run_to_block(2);

1437

1

1438

1

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

1439

1

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

1440

1

1441

1

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

1442

1

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

1443

1

1444

1

            assert_eq!(

1445

1

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

1446

1

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

1447

1

);

1448

1

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

1449

1

            assert_eq!(

1450

1

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

1451

1

                Some(100.into())

1452

1

);

1453

1

            assert_eq!(

1454

1

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

1455

1

                Some(100.into())

1456

1

);

1457

1

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

1458

1

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

1459

1460

            // In the next session the assignment will not change

1461

1

            assert_eq!(

1462

1

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

1463

1

                Some(100.into())

1464

1

);

1465

1

            assert_eq!(

1466

1

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

1467

1

                Some(100.into())

1468

1

);

1469

1

            assert_eq!(

1470

1

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

1471

1

                None,

1472

1

);

1473

1

            assert_eq!(

1474

1

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

1475

1

                None,

1476

1

);

1477

1478

            // Set CHARLIE and DAVE keys

1479

1

            assert_ok!(Session::set_keys(

1480

1

                origin_of(CHARLIE.into()),

1481

1

                crate::SessionKeys {

1482

1

                    nimbus: charlie_id.clone(),

1483

1

},

1484

1

                vec![]

1485

1

));

1486

1

            assert_ok!(Session::set_keys(

1487

1

                origin_of(DAVE.into()),

1488

1

                crate::SessionKeys {

1489

1

                    nimbus: dave_id.clone(),

1490

1

},

1491

1

                vec![]

1492

1

));

1493

1494

            // Set new invulnerables

1495

1

            assert_ok!(Invulnerables::add_invulnerable(

1496

1

                root_origin(),

1497

1

                CHARLIE.into()

1498

1

));

1499

1

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

1500

1501

1

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

1502

1

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

1503

1

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

1504

1

            // edge of a session change

1505

1

            run_to_block(session_two_edge - 2);

1506

1

1507

1

            assert_eq!(

1508

1

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

1509

1

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

1510

1

);

1511

1

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

1512

1

            assert_eq!(

1513

1

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

1514

1

                Some(100.into())

1515

1

);

1516

1

            assert_eq!(

1517

1

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

1518

1

                Some(100.into())

1519

1

);

1520

1

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

1521

1

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

1522

1523

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

1524

1

            assert_eq!(

1525

1

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

1526

1

                Some(100.into())

1527

1

);

1528

1

            assert_eq!(

1529

1

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

1530

1

                Some(100.into())

1531

1

);

1532

1

            assert_eq!(

1533

1

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

1534

1

                Some(1001.into()),

1535

1

);

1536

1

            assert_eq!(

1537

1

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

1538

1

                Some(1001.into()),

1539

1

);

1540

1541

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

1542

            // authorities of the next block!

1543

1

            run_to_block(session_two_edge - 1);

1544

1

            assert_eq!(

1545

1

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

1546

1

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

1547

1

);

1548

1

            assert_eq!(

1549

1

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

1550

1

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

1551

1

);

1552

1

            assert_eq!(

1553

1

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

1554

1

                Some(100.into())

1555

1

);

1556

1

            assert_eq!(

1557

1

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

1558

1

                Some(100.into())

1559

1

);

1560

1

            assert_eq!(

1561

1

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

1562

1

                Some(1001.into())

1563

1

);

1564

1

            assert_eq!(

1565

1

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

1566

1

                Some(1001.into())

1567

1

);

1568

1569

            // check_para_id_assignment_next_session returns the same value as check_para_id_assignment

1570

            // because we are on a session boundary

1571

1

            assert_eq!(

1572

1

                Runtime::check_para_id_assignment_next_session(alice_id),

1573

1

                Some(100.into())

1574

1

);

1575

1

            assert_eq!(

1576

1

                Runtime::check_para_id_assignment_next_session(bob_id),

1577

1

                Some(100.into())

1578

1

);

1579

1

            assert_eq!(

1580

1

                Runtime::check_para_id_assignment_next_session(charlie_id),

1581

1

                Some(1001.into())

1582

1

);

1583

1

            assert_eq!(

1584

1

                Runtime::check_para_id_assignment_next_session(dave_id),

1585

1

                Some(1001.into())

1586

1

);

1587

1

});

1588

1

1589

1590

#[test]

1591

1

fn test_author_noting_self_para_id_not_noting() {

1592

1

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

1593

1

        let mut sproof = ParaHeaderSproofBuilder::default();

1594

1

        let slot: u64 = 5;

1595

1

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

1596

1

        let s = ParaHeaderSproofBuilderItem {

1597

1

            para_id: self_para,

1598

1

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

1599

1

                parent_hash: Default::default(),

1600

1

                number: Default::default(),

1601

1

                state_root: Default::default(),

1602

1

                extrinsics_root: Default::default(),

1603

1

                digest: sp_runtime::generic::Digest {

1604

1

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

1605

1

},

1606

1

}),

1607

1

};

1608

1

        sproof.items.push(s);

1609

1

1610

1

        set_author_noting_inherent_data(sproof);

1611

1

1612

1

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

1613

1

});

1614

1

1615

1616

#[test]

1617

1

fn test_author_noting_not_self_para() {

1618

1

    ExtBuilder::default()

1619

1

        .with_balances(vec![

1620

1

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

1621

1

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

1622

1

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

1623

1

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

1624

1

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

1625

1

])

1626

1

        .with_collators(vec![

1627

1

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

1628

1

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

1629

1

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

1630

1

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

1631

1

])

1632

1

        .with_empty_parachains(vec![1001, 1002])

1633

1

        .build()

1634

1

        .execute_with(|| {

1635

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1636

1

            let slot: u64 = 5;

1637

1

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

1638

1

1639

1

            // Charlie and Dave to 1001

1640

1

            let assignment = CollatorAssignment::collator_container_chain();

1641

1

            assert_eq!(

1642

1

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

1643

1

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

1644

1

);

1645

1646

1

            let s = ParaHeaderSproofBuilderItem {

1647

1

                para_id: other_para,

1648

1

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

1649

1

                    parent_hash: Default::default(),

1650

1

                    number: 1,

1651

1

                    state_root: Default::default(),

1652

1

                    extrinsics_root: Default::default(),

1653

1

                    digest: sp_runtime::generic::Digest {

1654

1

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

1655

1

},

1656

1

}),

1657

1

};

1658

1

            sproof.items.push(s);

1659

1

1660

1

            set_author_noting_inherent_data(sproof);

1661

1

1662

1

            assert_eq!(

1663

1

                AuthorNoting::latest_author(other_para),

1664

1

                Some(ContainerChainBlockInfo {

1665

1

                    block_number: 1,

1666

1

                    author: AccountId::from(DAVE),

1667

1

                    latest_slot_number: 0.into(),

1668

1

})

1669

1

);

1670

1

});

1671

1

1672

1673

#[test]

1674

1

fn test_author_noting_set_author_and_kill_author_data() {

1675

1

    ExtBuilder::default()

1676

1

        .with_balances(vec![

1677

1

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

1678

1

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

1679

1

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

1680

1

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

1681

1

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

1682

1

])

1683

1

        .with_collators(vec![

1684

1

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

1685

1

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

1686

1

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

1687

1

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

1688

1

])

1689

1

        .with_empty_parachains(vec![1001, 1002])

1690

1

        .build()

1691

1

        .execute_with(|| {

1692

1

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

1693

1

1694

1

            assert_ok!(AuthorNoting::set_author(

1695

1

                root_origin(),

1696

1

                other_para,

1697

1

1,

1698

1

                AccountId::from(DAVE),

1699

1

                1.into()

1700

1

));

1701

1702

1

            assert_eq!(

1703

1

                AuthorNoting::latest_author(other_para),

1704

1

                Some(ContainerChainBlockInfo {

1705

1

                    block_number: 1,

1706

1

                    author: AccountId::from(DAVE),

1707

1

                    latest_slot_number: 1.into(),

1708

1

})

1709

1

);

1710

1711

1

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

1712

1713

1

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

1714

1

});

1715

1

1716

1717

#[test]

1718

1

fn test_author_noting_set_author_and_kill_author_data_bad_origin() {

1719

1

    ExtBuilder::default()

1720

1

        .with_balances(vec![

1721

1

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

1722

1

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

1723

1

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

1724

1

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

1725

1

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

1726

1

])

1727

1

        .with_collators(vec![

1728

1

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

1729

1

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

1730

1

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

1731

1

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

1732

1

])

1733

1

        .with_empty_parachains(vec![1001, 1002])

1734

1

        .build()

1735

1

        .execute_with(|| {

1736

1

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

1737

1

1738

1

            assert_noop!(

1739

1

                AuthorNoting::set_author(

1740

1

                    origin_of(ALICE.into()),

1741

1

                    other_para,

1742

1

1,

1743

1

                    AccountId::from(DAVE),

1744

1

                    1.into()

1745

1

),

1746

1

                BadOrigin

1747

1

);

1748

1749

1

            assert_noop!(

1750

1

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

1751

1

                BadOrigin

1752

1

);

1753

1

});

1754

1

1755

1756

#[test]

1757

1

fn test_author_noting_runtime_api() {

1758

1

    ExtBuilder::default()

1759

1

        .with_balances(vec![

1760

1

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

1761

1

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

1762

1

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

1763

1

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

1764

1

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

1765

1

])

1766

1

        .with_collators(vec![

1767

1

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

1768

1

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

1769

1

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

1770

1

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

1771

1

])

1772

1

        .with_empty_parachains(vec![1001, 1002])

1773

1

        .build()

1774

1

        .execute_with(|| {

1775

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1776

1

            let slot: u64 = 5;

1777

1

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

1778

1

1779

1

            // Charlie and Dave to 1001

1780

1

            let assignment = CollatorAssignment::collator_container_chain();

1781

1

            assert_eq!(

1782

1

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

1783

1

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

1784

1

);

1785

1786

1

            let s = ParaHeaderSproofBuilderItem {

1787

1

                para_id: other_para,

1788

1

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

1789

1

                    parent_hash: Default::default(),

1790

1

                    number: 1,

1791

1

                    state_root: Default::default(),

1792

1

                    extrinsics_root: Default::default(),

1793

1

                    digest: sp_runtime::generic::Digest {

1794

1

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

1795

1

},

1796

1

}),

1797

1

};

1798

1

            sproof.items.push(s);

1799

1

1800

1

            set_author_noting_inherent_data(sproof);

1801

1

1802

1

            assert_eq!(

1803

1

                AuthorNoting::latest_author(other_para),

1804

1

                Some(ContainerChainBlockInfo {

1805

1

                    block_number: 1,

1806

1

                    author: AccountId::from(DAVE),

1807

1

                    latest_slot_number: 0.into(),

1808

1

})

1809

1

);

1810

1811

1

            assert_eq!(

1812

1

                Runtime::latest_author(other_para),

1813

1

                Some(AccountId::from(DAVE))

1814

1

);

1815

1

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

1816

1

});

1817

1

1818

1819

#[test]

1820

1

fn session_keys_key_type_id() {

1821

1

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

1822

1

1823

1824

#[test]

1825

1

fn test_session_keys_with_authority_mapping() {

1826

1

    ExtBuilder::default()

1827

1

        .with_balances(vec![

1828

1

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

1829

1

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

1830

1

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

1831

1

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

1832

1

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

1833

1

])

1834

1

        .with_empty_parachains(vec![1001, 1002])

1835

1

        .build()

1836

1

        .execute_with(|| {

1837

1

            run_to_block(2);

1838

1

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

1839

1

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

1840

1

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

1841

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1842

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1843

1

1844

1

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

1845

1

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

1846

1

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

1847

1848

            // Everything should match to aura

1849

1

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

1850

1851

            // Change Alice and Bob keys to something different

1852

            // for now lets change it to alice_2 and bob_2

1853

1

            assert_ok!(Session::set_keys(

1854

1

                origin_of(ALICE.into()),

1855

1

                crate::SessionKeys {

1856

1

                    nimbus: alice_id_2.clone(),

1857

1

},

1858

1

                vec![]

1859

1

));

1860

1

            assert_ok!(Session::set_keys(

1861

1

                origin_of(BOB.into()),

1862

1

                crate::SessionKeys {

1863

1

                    nimbus: bob_id_2.clone(),

1864

1

},

1865

1

                vec![]

1866

1

));

1867

1868

1

            run_to_session(1u32);

1869

1

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

1870

1

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

1871

1

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

1872

1

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

1873

1874

1

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

1875

1

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

1876

1

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

1877

1

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

1878

1879

            // Everything should match to aura

1880

1

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

1881

//

1882

1883

1

            run_to_session(2u32);

1884

1

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

1885

1886

1

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

1887

1

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

1888

1

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

1889

1

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

1890

1891

1

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

1892

1

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

1893

1

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

1894

1

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

1895

1896

            // Everything should match to aura

1897

1

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

1898

1

});

1899

1

1900

1901

#[test]

1902

1

fn test_session_keys_with_authority_assignment() {

1903

1

    ExtBuilder::default()

1904

1

        .with_balances(vec![

1905

1

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

1906

1

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

1907

1

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

1908

1

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

1909

1

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

1910

1

])

1911

1

        .with_empty_parachains(vec![1001, 1002])

1912

1

        .build()

1913

1

        .execute_with(|| {

1914

1

            run_to_block(2);

1915

1

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

1916

1

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

1917

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1918

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1919

1

1920

1

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

1921

1

            assert_eq!(

1922

1

                key_mapping_session_0.orchestrator_chain,

1923

1

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

1924

1

);

1925

1

            assert_eq!(

1926

1

                CollatorAssignment::collator_container_chain().orchestrator_chain,

1927

1

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

1928

1

);

1929

1930

1

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

1931

1

            assert_eq!(key_mapping_session_1, key_mapping_session_0,);

1932

1

            let old_assignment_session_1 =

1933

1

                CollatorAssignment::pending_collator_container_chain().unwrap();

1934

1

            assert_eq!(

1935

1

                old_assignment_session_1,

1936

1

                CollatorAssignment::collator_container_chain(),

1937

1

);

1938

1939

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2);

1940

1

            assert!(key_mapping_session_2.is_none());

1941

1942

            // Everything should match to aura

1943

1

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

1944

1945

            // Change Alice and Bob keys to something different

1946

            // for now lets change it to alice_2 and bob_2

1947

1

            assert_ok!(Session::set_keys(

1948

1

                origin_of(ALICE.into()),

1949

1

                crate::SessionKeys {

1950

1

                    nimbus: alice_id_2.clone(),

1951

1

},

1952

1

                vec![]

1953

1

));

1954

1

            assert_ok!(Session::set_keys(

1955

1

                origin_of(BOB.into()),

1956

1

                crate::SessionKeys {

1957

1

                    nimbus: bob_id_2.clone(),

1958

1

},

1959

1

                vec![]

1960

1

));

1961

1962

1

            run_to_session(1u32);

1963

1

            let old_key_mapping_session_1 = key_mapping_session_1;

1964

1

1965

1

            // Session 0 got removed

1966

1

            let key_mapping_session_0 = AuthorityAssignment::collator_container_chain(0);

1967

1

            assert!(key_mapping_session_0.is_none());

1968

1969

            // The values at session 1 did not change

1970

1

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

1971

1

            assert_eq!(key_mapping_session_1, old_key_mapping_session_1,);

1972

1

            assert_eq!(

1973

1

                CollatorAssignment::collator_container_chain(),

1974

1

                old_assignment_session_1,

1975

1

);

1976

1977

            // Session 2 uses the new keys

1978

1

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

1979

1

            assert_eq!(

1980

1

                key_mapping_session_2.orchestrator_chain,

1981

1

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

1982

1

);

1983

1

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

1984

1985

1

            let key_mapping_session_3 = AuthorityAssignment::collator_container_chain(3);

1986

1

            assert!(key_mapping_session_3.is_none());

1987

1988

            // Everything should match to aura

1989

1

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

1990

1991

1

            run_to_session(2u32);

1992

1

1993

1

            // Session 1 got removed

1994

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1);

1995

1

            assert!(key_mapping_session_1.is_none());

1996

1997

            // Session 2 uses the new keys

1998

1

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

1999

1

            assert_eq!(

2000

1

                key_mapping_session_2.orchestrator_chain,

2001

1

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

2002

1

);

2003

1

            assert_eq!(

2004

1

                old_assignment_session_1,

2005

1

                CollatorAssignment::collator_container_chain(),

2006

1

);

2007

2008

            // Session 3 uses the new keys

2009

1

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

2010

1

            assert_eq!(

2011

1

                key_mapping_session_3.orchestrator_chain,

2012

1

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

2013

1

);

2014

1

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

2015

2016

1

            let key_mapping_session_4 = AuthorityAssignment::collator_container_chain(4);

2017

1

            assert!(key_mapping_session_4.is_none());

2018

2019

            // Everything should match to aura

2020

1

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

2021

1

});

2022

1

2023

2024

2

fn call_transfer(

2025

2

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

2026

2

    value: u128,

2027

2

) -> RuntimeCall {

2028

2

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

2029

2

2030

2031

#[test]

2032

1

fn test_proxy_any() {

2033

1

    ExtBuilder::default()

2034

1

        .with_balances(vec![

2035

1

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

2036

1

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

2037

1

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

2038

1

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

2039

1

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

2040

1

])

2041

1

        .build()

2042

1

        .execute_with(|| {

2043

1

            run_to_block(2);

2044

1

2045

1

            let delay = 0;

2046

1

            assert_ok!(Proxy::add_proxy(

2047

1

                origin_of(ALICE.into()),

2048

1

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

2049

1

                ProxyType::Any,

2050

1

                delay

2051

1

));

2052

2053

1

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

2054

1

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

2055

1

            assert_ok!(Proxy::proxy(

2056

1

                origin_of(BOB.into()),

2057

1

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

2058

1

                None,

2059

1

                call

2060

1

));

2061

1

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

2062

1

2063

1

            assert_eq!(balance_after, balance_before + 200_000);

2064

1

});

2065

1

2066

2067

#[test]

2068

1

fn test_proxy_non_transfer() {

2069

1

    ExtBuilder::default()

2070

1

        .with_balances(vec![

2071

1

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

2072

1

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

2073

1

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

2074

1

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

2075

1

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

2076

1

])

2077

1

        .build()

2078

1

        .execute_with(|| {

2079

1

            run_to_block(2);

2080

1

2081

1

            let delay = 0;

2082

1

            assert_ok!(Proxy::add_proxy(

2083

1

                origin_of(ALICE.into()),

2084

1

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

2085

1

                ProxyType::NonTransfer,

2086

1

                delay

2087

1

));

2088

2089

1

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

2090

1

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

2091

1

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

2092

1

            assert_ok!(Proxy::proxy(

2093

1

                origin_of(BOB.into()),

2094

1

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

2095

1

                None,

2096

1

                call

2097

1

));

2098

1

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

2099

1

2100

1

            assert_eq!(balance_after, balance_before);

2101

1

});

2102

1

2103

2104

#[test]

2105

1

fn test_proxy_utility() {

2106

1

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

2107

1

    // subcalls don't allow to circumvent filters.

2108

1

2109

1

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

2110

1

    match ProxyType::Any {

2111

        ProxyType::Any

2112

        | ProxyType::NonTransfer

2113

        | ProxyType::Governance

2114

        | ProxyType::Staking

2115

        | ProxyType::CancelProxy

2116

        | ProxyType::Balances

2117

        | ProxyType::Registrar

2118

1

        | ProxyType::SudoRegistrar => (),

2119

1

};

2120

1

2121

1

    // All except for any

2122

1

    let proxy_types = &[

2123

1

        ProxyType::NonTransfer,

2124

1

        ProxyType::Governance,

2125

1

        ProxyType::Staking,

2126

1

        ProxyType::CancelProxy,

2127

1

        ProxyType::Balances,

2128

1

        ProxyType::Registrar,

2129

1

        ProxyType::SudoRegistrar,

2130

1

];

2131

2132

8

    for &proxy_type in proxy_types {

2133

7

        ExtBuilder::default()

2134

7

            .with_balances(vec![

2135

7

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

2136

7

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

2137

7

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

2138

7

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

2139

7

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

2140

7

])

2141

7

            .with_sudo(AccountId::from(ALICE))

2142

7

            .build()

2143

7

            .execute_with(|| {

2144

7

                assert_ok!(Proxy::add_proxy(

2145

7

                    origin_of(ALICE.into()),

2146

7

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

2147

7

                    proxy_type,

2148

7

2149

7

));

2150

2151

7

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

2152

7

2153

7

                assert_ok!(Proxy::proxy(

2154

7

                    origin_of(BOB.into()),

2155

7

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

2156

7

                    None,

2157

7

                    Box::new(

2158

7

                        pallet_sudo::Call::sudo {

2159

7

                            call: Box::new(

2160

7

                                pallet_utility::Call::batch {

2161

7

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

2162

7

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

2163

7

                                        new_free: 42424242424242

2164

7

2165

7

                                    .into()]

2166

7

2167

7

                                .into()

2168

7

2169

7

2170

7

                        .into()

2171

7

2172

7

));

2173

2174

7

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

2175

7

});

2176

7

2177

1

2178

2179

#[test]

2180

1

fn check_well_known_keys() {

2181

    use frame_support::traits::PalletInfo;

2182

2183

    // Pallet is named "Paras" in Polkadot.

2184

1

    assert_eq!(

2185

1

        well_known_keys::PARAS_HEADS_INDEX,

2186

1

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

2187

1

);

2188

2189

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

2190

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

2191

1

    assert_eq!(

2192

1

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

2193

1

        Some("AuthorityAssignment")

2194

1

);

2195

1

    assert_eq!(

2196

1

        well_known_keys::AUTHORITY_ASSIGNMENT_PREFIX,

2197

1

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

2198

1

);

2199

2200

1

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

2201

1

    assert_eq!(

2202

1

        well_known_keys::SESSION_INDEX,

2203

1

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

2204

1

);

2205

1

2206

2207

#[test]

2208

1

fn test_reward_to_invulnerable() {

2209

1

    // Alice, Bob, Charlie are invulnerables

2210

1

    ExtBuilder::default()

2211

1

        .with_balances(vec![

2212

1

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

2213

1

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

2214

1

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

2215

1

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

2216

1

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

2217

1

])

2218

1

        .with_collators(vec![

2219

1

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

2220

1

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

2221

1

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

2222

1

])

2223

1

        .with_empty_parachains(vec![1001, 1002])

2224

1

        .build()

2225

1

        .execute_with(|| {

2226

1

            run_to_block(2);

2227

1

2228

1

            // We make delegations to ALICE so that she is an elligible candidate.

2229

1

            // However since she is an invulnerable she should get all the

2230

1

            // rewards.

2231

1

2232

1

            // wait for next session so that ALICE is elected

2233

1

            run_to_session(4u32);

2234

1

2235

1

            let account: AccountId = ALICE.into();

2236

1

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

2237

1

2238

1

            let summary = (0..100)

2239

2

                .find_map(|_| {

2240

2

                    let summary = run_block();

2241

2

                    if summary.author_id == ALICE.into() {

2242

1

                        Some(summary)

2243

                    } else {

2244

1

                        None

2245

2246

2

})

2247

1

                .unwrap_or_else(|| panic!("ALICE doesn't seem to author any blocks"));

2248

1

2249

1

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

2250

1

2251

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

2252

1

            // rewards are shared between orchestrator and registered paras

2253

1

            let orchestrator_rewards = all_rewards / 3;

2254

1

            assert_eq!(

2255

1

                orchestrator_rewards,

2256

1

                balance_after - balance_before,

2257

                "alice should get the correct reward portion"

2258

);

2259

1

});

2260

1

2261

2262

#[test]

2263

1

fn test_reward_to_invulnerable_with_key_change() {

2264

1

    ExtBuilder::default()

2265

1

        .with_balances(vec![

2266

1

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

2267

1

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

2268

1

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

2269

1

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

2270

1

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

2271

1

])

2272

1

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

2273

1

        .with_empty_parachains(vec![1001, 1002])

2274

1

        .build()

2275

1

        .execute_with(|| {

2276

1

            run_to_block(2);

2277

1

2278

1

            run_to_session(2u32);

2279

1

2280

1

            // change key, this should be reflected 2 sessions afterward

2281

1

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

2282

1

            assert_ok!(Session::set_keys(

2283

1

                origin_of(ALICE.into()),

2284

1

                crate::SessionKeys {

2285

1

                    nimbus: alice_new_key,

2286

1

},

2287

1

                vec![]

2288

1

));

2289

2290

1

            run_to_session(4u32);

2291

1

2292

1

            let account: AccountId = ALICE.into();

2293

1

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

2294

1

2295

1

            let summary = run_block();

2296

1

            assert_eq!(summary.author_id, ALICE.into());

2297

2298

1

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

2299

1

2300

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

2301

1

            // rewards are shared between orchestrator and registered paras

2302

1

            let orchestrator_rewards = all_rewards / 3;

2303

1

            assert_eq!(

2304

1

                orchestrator_rewards,

2305

1

                balance_after - balance_before,

2306

                "alice should get the correct reward portion"

2307

);

2308

1

});

2309

1

2310

2311

#[test]

2312

1

fn test_can_buy_credits_before_registering_para() {

2313

1

    ExtBuilder::default()

2314

1

        .with_balances(vec![

2315

1

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

2316

1

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

2317

1

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

2318

1

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

2319

1

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

2320

1

])

2321

1

        .with_collators(vec![

2322

1

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

2323

1

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

2324

1

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

2325

1

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

2326

1

])

2327

1

        .build()

2328

1

        .execute_with(|| {

2329

1

            run_to_block(2);

2330

1

2331

1

            // Try to buy the maximum amount of credits

2332

1

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

2333

1

            assert_ok!(ServicesPayment::purchase_credits(

2334

1

                origin_of(ALICE.into()),

2335

1

                1001.into(),

2336

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

2337

1

));

2338

1

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

2339

1

2340

1

            // Now parachain tank should have this amount

2341

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

2342

1

                .data

2343

1

                .free;

2344

1

2345

1

            assert_eq!(

2346

1

                balance_tank,

2347

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

2348

1

);

2349

2350

1

            let expected_cost = block_credits_to_required_balance(u32::MAX, 1001.into());

2351

1

            assert_eq!(balance_before - balance_after, expected_cost);

2352

1

});

2353

1

2354

2355

#[test]

2356

1

fn test_cannot_mark_valid_para_with_no_bootnodes() {

2357

1

    ExtBuilder::default()

2358

1

        .with_balances(vec![

2359

1

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

2360

1

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

2361

1

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

2362

1

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

2363

1

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

2364

1

])

2365

1

        .with_collators(vec![

2366

1

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

2367

1

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

2368

1

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

2369

1

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

2370

1

])

2371

1

        .build()

2372

1

        .execute_with(|| {

2373

1

            run_to_block(2);

2374

1

            assert_ok!(Registrar::register(

2375

1

                origin_of(ALICE.into()),

2376

1

                1001.into(),

2377

1

                empty_genesis_data(),

2378

1

                None

2379

1

));

2380

1

            assert_noop!(

2381

1

                Registrar::mark_valid_for_collating(root_origin(), 1001.into()),

2382

1

                pallet_data_preservers::Error::<Runtime>::NoBootNodes,

2383

1

);

2384

1

});

2385

1

2386

2387

#[test]

2388

1

fn test_can_buy_credits_before_registering_para_and_receive_free_credits() {

2389

1

    ExtBuilder::default()

2390

1

        .with_balances(vec![

2391

1

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

2392

1

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

2393

1

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

2394

1

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

2395

1

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

2396

1

])

2397

1

        .with_collators(vec![

2398

1

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

2399

1

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

2400

1

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

2401

1

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

2402

1

])

2403

1

        .build()

2404

1

        .execute_with(|| {

2405

1

            run_to_block(2);

2406

1

2407

1

            // Try to buy (FreeBlockProductionCredits - 1) credits

2408

1

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

2409

1

            assert_ok!(ServicesPayment::purchase_credits(

2410

1

                origin_of(ALICE.into()),

2411

1

                1001.into(),

2412

1

                block_credits_to_required_balance(

2413

1

                    crate::FreeBlockProductionCredits::get() - 1,

2414

1

                    1001.into()

2415

1

2416

1

));

2417

1

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

2418

1

2419

1

            // Now parachain tank should have this amount

2420

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

2421

1

                .data

2422

1

                .free;

2423

1

2424

1

            assert_eq!(

2425

1

                balance_tank,

2426

1

                block_credits_to_required_balance(

2427

1

                    crate::FreeBlockProductionCredits::get() - 1,

2428

1

                    1001.into()

2429

1

2430

1

);

2431

2432

1

            let expected_cost = block_credits_to_required_balance(

2433

1

                crate::FreeBlockProductionCredits::get() - 1,

2434

1

                1001.into(),

2435

1

);

2436

1

            assert_eq!(balance_before - balance_after, expected_cost);

2437

2438

            // Now register para

2439

1

            assert_ok!(Registrar::register(

2440

1

                origin_of(ALICE.into()),

2441

1

                1001.into(),

2442

1

                empty_genesis_data(),

2443

1

                None

2444

1

));

2445

1

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

2446

1

            assert_ok!(Registrar::mark_valid_for_collating(

2447

1

                root_origin(),

2448

1

                1001.into()

2449

1

));

2450

2451

            // We received aññ free credits, because we cannot have more than FreeBlockProductionCredits

2452

1

            let credits =

2453

1

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

2454

1

                    .unwrap_or_default();

2455

1

            assert_eq!(credits, crate::FreeBlockProductionCredits::get());

2456

1

});

2457

1

2458

2459

#[test]

2460

1

fn test_deregister_and_register_again_does_not_give_free_credits() {

2461

1

    ExtBuilder::default()

2462

1

        .with_balances(vec![

2463

1

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

2464

1

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

2465

1

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

2466

1

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

2467

1

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

2468

1

])

2469

1

        .with_collators(vec![

2470

1

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

2471

1

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

2472

1

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

2473

1

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

2474

1

])

2475

1

        .build()

2476

1

        .execute_with(|| {

2477

1

            run_to_block(2);

2478

1

2479

1

            // Register

2480

1

            assert_ok!(Registrar::register(

2481

1

                origin_of(ALICE.into()),

2482

1

                1001.into(),

2483

1

                empty_genesis_data(),

2484

1

                None

2485

1

            ),);

2486

1

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

2487

1

            assert_ok!(Registrar::mark_valid_for_collating(

2488

1

                root_origin(),

2489

1

                1001.into()

2490

1

            ),);

2491

            // We received free credits

2492

1

            let credits =

2493

1

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

2494

1

                    .unwrap_or_default();

2495

1

            assert_eq!(credits, crate::FreeBlockProductionCredits::get());

2496

            // Deregister after 1 session

2497

1

            run_to_session(1);

2498

1

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

2499

2500

1

            run_to_session(3);

2501

1

            let credits_before_2nd_register =

2502

1

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

2503

1

                    .unwrap_or_default();

2504

1

            // We spent some credits because this container chain had collators for 1 session

2505

1

            assert_ne!(

2506

1

                credits_before_2nd_register,

2507

1

                crate::FreeBlockProductionCredits::get()

2508

1

);

2509

            // Register again

2510

1

            assert_ok!(Registrar::register(

2511

1

                origin_of(ALICE.into()),

2512

1

                1001.into(),

2513

1

                empty_genesis_data(),

2514

1

                None

2515

1

            ),);

2516

1

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

2517

1

            assert_ok!(Registrar::mark_valid_for_collating(

2518

1

                root_origin(),

2519

1

                1001.into()

2520

1

            ),);

2521

            // No more free credits

2522

1

            let credits =

2523

1

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

2524

1

                    .unwrap_or_default();

2525

1

            assert_eq!(credits, credits_before_2nd_register);

2526

1

});

2527

1

2528

2529

#[test]

2530

1

fn test_register_parathread_not_allowed() {

2531

1

    ExtBuilder::default()

2532

1

        .with_balances(vec![

2533

1

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

2534

1

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

2535

1

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

2536

1

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

2537

1

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

2538

1

])

2539

1

        .with_collators(vec![

2540

1

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

2541

1

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

2542

1

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

2543

1

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

2544

1

])

2545

1

        .build()

2546

1

        .execute_with(|| {

2547

1

            run_to_block(2);

2548

1

2549

1

            assert_noop!(

2550

1

                RuntimeCall::Registrar(pallet_registrar::Call::<Runtime>::register_parathread {

2551

1

                    para_id: 3001.into(),

2552

1

                    slot_frequency: SlotFrequency { min: 1, max: 1 },

2553

1

                    genesis_data: empty_genesis_data(),

2554

1

                    head_data: None

2555

1

})

2556

1

                .dispatch(

2557

1

                    <Runtime as frame_system::Config>::RuntimeOrigin::signed(AccountId::from(

2558

1

                        ALICE

2559

1

))

2560

1

),

2561

1

                frame_system::Error::<Runtime>::CallFiltered

2562

1

);

2563

1

});

2564

1

2565

2566

#[test]

2567

1

fn test_register_parathread_genesis() {

2568

1

    let parathread_params = tp_traits::ParathreadParams {

2569

1

        slot_frequency: SlotFrequency { min: 1, max: 1 },

2570

1

};

2571

1

    ExtBuilder::default()

2572

1

        .with_balances(vec![

2573

1

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

2574

1

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

2575

1

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

2576

1

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

2577

1

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

2578

1

])

2579

1

        .with_collators(vec![

2580

1

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

2581

1

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

2582

1

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

2583

1

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

2584

1

])

2585

1

        .with_para_ids(vec![ParaRegistrationParams {

2586

1

            para_id: 3001,

2587

1

            genesis_data: empty_genesis_data(),

2588

1

            block_production_credits: u32::MAX,

2589

1

            collator_assignment_credits: u32::MAX,

2590

1

            parathread_params: Some(parathread_params.clone()),

2591

1

}])

2592

1

        .build()

2593

1

        .execute_with(|| {

2594

1

            run_to_block(2);

2595

1

2596

1

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

2597

1

            assert_eq!(

2598

1

                pallet_registrar::ParathreadParams::<Runtime>::get(ParaId::from(3001)),

2599

1

                Some(parathread_params)

2600

1

);

2601

2602

1

            let assignment = CollatorAssignment::collator_container_chain();

2603

1

            assert_eq!(

2604

1

                assignment.container_chains[&ParaId::from(3001)],

2605

1

                vec![CHARLIE.into()]

2606

1

);

2607

1

});

2608

1

2609

2610

#[test]

2611

1

fn test_ed_plus_block_credit_session_purchase_works() {

2612

1

    ExtBuilder::default()

2613

1

        .with_balances(vec![

2614

1

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

2615

1

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

2616

1

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

2617

1

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

2618

1

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

2619

1

])

2620

1

        .with_collators(vec![

2621

1

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

2622

1

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

2623

1

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

2624

1

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

2625

1

])

2626

1

        .build()

2627

1

        .execute_with(|| {

2628

1

            run_to_block(2);

2629

1

            // Assert current slot gets updated

2630

1

            assert_eq!(current_slot(), 1u64);

2631

1

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

2632

2633

            // Alice and Bob collate in our chain

2634

1

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

2635

1

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

2636

1

2637

1

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

2638

2639

1

            assert_ok!(Registrar::register(

2640

1

                origin_of(ALICE.into()),

2641

1

                1001.into(),

2642

1

                empty_genesis_data(),

2643

1

                None

2644

1

));

2645

1

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

2646

1

            assert_ok!(Registrar::mark_valid_for_collating(

2647

1

                root_origin(),

2648

1

                1001.into()

2649

1

));

2650

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

2651

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2652

1

                root_origin(),

2653

1

                1001.into(),

2654

1

2655

1

));

2656

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

2657

1

                + crate::EXISTENTIAL_DEPOSIT;

2658

1

2659

1

            // Fill the tank

2660

1

            assert_ok!(ServicesPayment::purchase_credits(

2661

1

                origin_of(ALICE.into()),

2662

1

                1001.into(),

2663

1

                credits_1001

2664

1

));

2665

2666

            // Assignment should happen after 2 sessions

2667

1

            run_to_session(1u32);

2668

1

            let assignment = CollatorAssignment::collator_container_chain();

2669

1

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

2670

1

            run_to_session(2u32);

2671

1

            // Charlie and Dave should be assigned to para 1001

2672

1

            let assignment = CollatorAssignment::collator_container_chain();

2673

1

            assert_eq!(

2674

1

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

2675

1

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

2676

1

);

2677

2678

            // Simulate block inclusion from container chain 1001

2679

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

2680

1

            let slot: u64 = 5;

2681

1

            let s = ParaHeaderSproofBuilderItem {

2682

1

                para_id: 1001.into(),

2683

1

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

2684

1

                    parent_hash: Default::default(),

2685

1

                    number: 1,

2686

1

                    state_root: Default::default(),

2687

1

                    extrinsics_root: Default::default(),

2688

1

                    digest: sp_runtime::generic::Digest {

2689

1

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

2690

1

},

2691

1

}),

2692

1

};

2693

1

2694

1

            sproof.items.push(s);

2695

1

            set_author_noting_inherent_data(sproof);

2696

1

2697

1

            run_block();

2698

1

2699

1

            // After this it should not be assigned anymore, since credits are not payable

2700

1

            run_to_session(3u32);

2701

1

            // Nobody should be assigned to para 1001

2702

1

            let assignment = CollatorAssignment::collator_container_chain();

2703

1

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

2704

1

});

2705

1

2706

2707

#[test]

2708

1

fn test_ed_plus_block_credit_session_minus_1_purchase_fails() {

2709

1

    ExtBuilder::default()

2710

1

        .with_balances(vec![

2711

1

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

2712

1

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

2713

1

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

2714

1

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

2715

1

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

2716

1

])

2717

1

        .with_collators(vec![

2718

1

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

2719

1

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

2720

1

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

2721

1

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

2722

1

])

2723

1

        .build()

2724

1

        .execute_with(|| {

2725

1

            run_to_block(2);

2726

1

            // Assert current slot gets updated

2727

1

            assert_eq!(current_slot(), 1u64);

2728

1

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

2729

2730

            // Alice and Bob collate in our chain

2731

1

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

2732

1

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

2733

1

2734

1

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

2735

2736

1

            assert_ok!(Registrar::register(

2737

1

                origin_of(ALICE.into()),

2738

1

                1001.into(),

2739

1

                empty_genesis_data(),

2740

1

                None

2741

1

));

2742

1

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

2743

1

            assert_ok!(Registrar::mark_valid_for_collating(

2744

1

                root_origin(),

2745

1

                1001.into()

2746

1

));

2747

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

2748

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2749

1

                root_origin(),

2750

1

                1001.into(),

2751

1

2752

1

));

2753

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

2754

1

                + crate::EXISTENTIAL_DEPOSIT

2755

1

                - 1;

2756

1

2757

1

            // Fill the tank

2758

1

            assert_ok!(ServicesPayment::purchase_credits(

2759

1

                origin_of(ALICE.into()),

2760

1

                1001.into(),

2761

1

                credits_1001

2762

1

));

2763

2764

            // Assignment should happen after 2 sessions

2765

1

            run_to_session(1u32);

2766

1

            let assignment = CollatorAssignment::collator_container_chain();

2767

1

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

2768

1

            run_to_session(2u32);

2769

1

            // Charlie and Dave should not be assigned to para 1001

2770

1

            let assignment = CollatorAssignment::collator_container_chain();

2771

1

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

2772

1

});

2773

1

2774

2775

#[test]

2776

1

fn test_reassignment_ed_plus_two_block_credit_session_purchase_works() {

2777

1

    ExtBuilder::default()

2778

1

        .with_balances(vec![

2779

1

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

2780

1

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

2781

1

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

2782

1

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

2783

1

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

2784

1

])

2785

1

        .with_collators(vec![

2786

1

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

2787

1

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

2788

1

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

2789

1

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

2790

1

])

2791

1

        .build()

2792

1

        .execute_with(|| {

2793

1

            run_to_block(2);

2794

1

            // Assert current slot gets updated

2795

1

            assert_eq!(current_slot(), 1u64);

2796

1

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

2797

2798

            // Alice and Bob collate in our chain

2799

1

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

2800

1

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

2801

1

2802

1

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

2803

2804

1

            assert_ok!(Registrar::register(

2805

1

                origin_of(ALICE.into()),

2806

1

                1001.into(),

2807

1

                empty_genesis_data(),

2808

1

                None

2809

1

));

2810

1

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

2811

1

            assert_ok!(Registrar::mark_valid_for_collating(

2812

1

                root_origin(),

2813

1

                1001.into()

2814

1

));

2815

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

2816

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2817

1

                root_origin(),

2818

1

                1001.into(),

2819

1

2820

1

));

2821

            // On reassignment the blocks credits needed should be enough for the current session and the next one

2822

1

            let credits_1001 =

2823

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into())

2824

1

                    + crate::EXISTENTIAL_DEPOSIT;

2825

1

2826

1

            // Fill the tank

2827

1

            assert_ok!(ServicesPayment::purchase_credits(

2828

1

                origin_of(ALICE.into()),

2829

1

                1001.into(),

2830

1

                credits_1001

2831

1

));

2832

2833

            // Assignment should happen after 2 sessions

2834

1

            run_to_session(1u32);

2835

1

            let assignment = CollatorAssignment::collator_container_chain();

2836

1

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

2837

2838

1

            run_to_session(2u32);

2839

1

            // Charlie and Dave should be assigned to para 1001

2840

1

            let assignment = CollatorAssignment::collator_container_chain();

2841

1

            assert_eq!(

2842

1

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

2843

1

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

2844

1

);

2845

2846

            // Simulate block inclusion from container chain 1001

2847

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

2848

1

            let slot: u64 = 5;

2849

1

            let s = ParaHeaderSproofBuilderItem {

2850

1

                para_id: 1001.into(),

2851

1

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

2852

1

                    parent_hash: Default::default(),

2853

1

                    number: 1,

2854

1

                    state_root: Default::default(),

2855

1

                    extrinsics_root: Default::default(),

2856

1

                    digest: sp_runtime::generic::Digest {

2857

1

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

2858

1

},

2859

1

}),

2860

1

};

2861

1

2862

1

            sproof.items.push(s);

2863

1

            set_author_noting_inherent_data(sproof);

2864

1

2865

1

            run_block();

2866

1

2867

1

            // Session 3 should still be assigned

2868

1

            run_to_session(3u32);

2869

1

            // Charlie and Dave should be assigned to para 1001

2870

1

            let assignment = CollatorAssignment::collator_container_chain();

2871

1

            assert_eq!(

2872

1

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

2873

1

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

2874

1

);

2875

2876

            // After this it should not be assigned anymore, since credits are not payable

2877

1

            run_to_session(4u32);

2878

1

            // Nobody should be assigned to para 1001

2879

1

            let assignment = CollatorAssignment::collator_container_chain();

2880

1

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

2881

1

});

2882

1

2883

2884

#[test]

2885

1

fn test_reassignment_ed_plus_two_block_credit_session_minus_1_purchase_fails() {

2886

1

    ExtBuilder::default()

2887

1

        .with_balances(vec![

2888

1

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

2889

1

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

2890

1

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

2891

1

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

2892

1

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

2893

1

])

2894

1

        .with_collators(vec![

2895

1

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

2896

1

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

2897

1

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

2898

1

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

2899

1

])

2900

1

        .build()

2901

1

        .execute_with(|| {

2902

1

            run_to_block(2);

2903

1

            // Assert current slot gets updated

2904

1

            assert_eq!(current_slot(), 1u64);

2905

1

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

2906

2907

            // Alice and Bob collate in our chain

2908

1

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

2909

1

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

2910

1

2911

1

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

2912

2913

1

            assert_ok!(Registrar::register(

2914

1

                origin_of(ALICE.into()),

2915

1

                1001.into(),

2916

1

                empty_genesis_data(),

2917

1

                None

2918

1

));

2919

1

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

2920

1

            assert_ok!(Registrar::mark_valid_for_collating(

2921

1

                root_origin(),

2922

1

                1001.into()

2923

1

));

2924

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

2925

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2926

1

                root_origin(),

2927

1

                1001.into(),

2928

1

2929

1

));

2930

1

            let credits_1001 =

2931

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into())

2932

1

                    + crate::EXISTENTIAL_DEPOSIT

2933

1

                    - 1;

2934

1

2935

1

            // Fill the tank

2936

1

            assert_ok!(ServicesPayment::purchase_credits(

2937

1

                origin_of(ALICE.into()),

2938

1

                1001.into(),

2939

1

                credits_1001

2940

1

));

2941

2942

            // Assignment should happen after 2 sessions

2943

1

            run_to_session(1u32);

2944

1

            let assignment = CollatorAssignment::collator_container_chain();

2945

1

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

2946

2947

1

            run_to_session(2u32);

2948

1

            // Charlie and Dave should be assigned to para 1001

2949

1

            let assignment = CollatorAssignment::collator_container_chain();

2950

1

            assert_eq!(

2951

1

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

2952

1

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

2953

1

);

2954

2955

            // Simulate block inclusion from container chain 1001

2956

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

2957

1

            let slot: u64 = 5;

2958

1

            let s = ParaHeaderSproofBuilderItem {

2959

1

                para_id: 1001.into(),

2960

1

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

2961

1

                    parent_hash: Default::default(),

2962

1

                    number: 1,

2963

1

                    state_root: Default::default(),

2964

1

                    extrinsics_root: Default::default(),

2965

1

                    digest: sp_runtime::generic::Digest {

2966

1

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

2967

1

},

2968

1

}),

2969

1

};

2970

1

2971

1

            sproof.items.push(s);

2972

1

            set_author_noting_inherent_data(sproof);

2973

1

2974

1

            run_block();

2975

1

2976

1

            // After this it should not be assigned anymore, since credits are not payable

2977

1

            run_to_session(3u32);

2978

1

            // Nobody should be assigned to para 1001

2979

1

            let assignment = CollatorAssignment::collator_container_chain();

2980

1

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

2981

1

});

2982

1

2983

2984

#[test]

2985

1

fn test_credits_with_purchase_can_be_combined() {

2986

1

    ExtBuilder::default()

2987

1

        .with_balances(vec![

2988

1

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

2989

1

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

2990

1

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

2991

1

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

2992

1

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

2993

1

])

2994

1

        .with_collators(vec![

2995

1

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

2996

1

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

2997

1

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

2998

1

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

2999

1

])

3000

1

        .build()

3001

1

        .execute_with(|| {

3002

1

            run_to_block(2);

3003

1

            // Assert current slot gets updated

3004

1

            assert_eq!(current_slot(), 1u64);

3005

1

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

3006

3007

            // Alice and Bob collate in our chain

3008

1

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

3009

1

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

3010

1

3011

1

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

3012

3013

1

            assert_ok!(Registrar::register(

3014

1

                origin_of(ALICE.into()),

3015

1

                1001.into(),

3016

1

                empty_genesis_data(),

3017

1

                None

3018

1

));

3019

1

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

3020

1

            assert_ok!(Registrar::mark_valid_for_collating(

3021

1

                root_origin(),

3022

1

                1001.into()

3023

1

));

3024

            // Set 1 session of free credits and purchase 1 session of credits

3025

1

            assert_ok!(ServicesPayment::set_block_production_credits(

3026

1

                root_origin(),

3027

1

                1001.into(),

3028

1

                crate::Period::get()

3029

1

));

3030

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

3031

1

                + crate::EXISTENTIAL_DEPOSIT;

3032

1

3033

1

            // Fill the tank

3034

1

            assert_ok!(ServicesPayment::purchase_credits(

3035

1

                origin_of(ALICE.into()),

3036

1

                1001.into(),

3037

1

                credits_1001

3038

1

));

3039

3040

            // Assignment should happen after 2 sessions

3041

1

            run_to_session(1u32);

3042

1

            let assignment = CollatorAssignment::collator_container_chain();

3043

1

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

3044

1

            run_to_session(2u32);

3045

1

            // Charlie and Dave should be assigned to para 1001

3046

1

            let assignment = CollatorAssignment::collator_container_chain();

3047

1

            assert_eq!(

3048

1

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

3049

1

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

3050

1

);

3051

1

});

3052

1

3053

#[test]

3054

1

fn stream_payment_works() {

3055

1

    ExtBuilder::default()

3056

1

        .with_balances(vec![

3057

1

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

3058

1

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

3059

1

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

3060

1

])

3061

1

        .with_collators(vec![

3062

1

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

3063

1

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

3064

1

])

3065

1

        .build()

3066

1

        .execute_with(|| {

3067

            use pallet_stream_payment::{ChangeKind, StreamConfig};

3068

3069

1

            assert_ok!(StreamPayment::open_stream(

3070

1

                origin_of(ALICE.into()),

3071

1

                BOB.into(),

3072

1

                StreamConfig {

3073

1

                    rate: 2 * UNIT,

3074

1

                    asset_id: StreamPaymentAssetId::Native,

3075

1

                    time_unit: TimeUnit::BlockNumber,

3076

1

},

3077

1

                1_000 * UNIT,

3078

1

));

3079

3080

1

            run_block();

3081

1

3082

1

            assert_ok!(StreamPayment::perform_payment(origin_of(CHARLIE.into()), 0));

3083

1

            assert_eq!(

3084

1

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

3085

1

                100_000 * UNIT + 2 * UNIT

3086

1

);

3087

3088

1

            assert_ok!(StreamPayment::request_change(

3089

1

                origin_of(ALICE.into()),

3090

1

0,

3091

1

                ChangeKind::Suggestion,

3092

1

                StreamConfig {

3093

1

                    rate: 1 * UNIT,

3094

1

                    asset_id: StreamPaymentAssetId::Native,

3095

1

                    time_unit: TimeUnit::BlockNumber,

3096

1

},

3097

1

                None,

3098

1

));

3099

3100

1

            assert_ok!(StreamPayment::accept_requested_change(

3101

1

                origin_of(BOB.into()),

3102

1

0,

3103

1

                1, // nonce

3104

1

                None,

3105

1

));

3106

3107

1

            run_block();

3108

1

3109

1

            assert_ok!(StreamPayment::close_stream(origin_of(BOB.into()), 0));

3110

3111

1

            assert_eq!(

3112

1

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

3113

1

                100_000 * UNIT + 3 * UNIT

3114

1

);

3115

1

            assert_eq!(

3116

1

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

3117

1

                100_000 * UNIT - 3 * UNIT

3118

1

);

3119

1

});

3120

1

3121

3122

#[test]

3123

1

fn test_ed_plus_collator_assignment_session_purchase_works() {

3124

1

    ExtBuilder::default()

3125

1

        .with_balances(vec![

3126

1

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

3127

1

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

3128

1

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

3129

1

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

3130

1

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

3131

1

])

3132

1

        .with_collators(vec![

3133

1

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

3134

1

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

3135

1

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

3136

1

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

3137

1

])

3138

1

        .build()

3139

1

        .execute_with(|| {

3140

1

            run_to_block(2);

3141

1

            // Assert current slot gets updated

3142

1

            assert_eq!(current_slot(), 1u64);

3143

1

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

3144

3145

            // Alice and Bob collate in our chain

3146

1

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

3147

1

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

3148

1

3149

1

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

3150

3151

1

            assert_ok!(Registrar::register(

3152

1

                origin_of(ALICE.into()),

3153

1

                1001.into(),

3154

1

                empty_genesis_data(),

3155

1

                None

3156

1

));

3157

1

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

3158

1

            assert_ok!(Registrar::mark_valid_for_collating(

3159

1

                root_origin(),

3160

1

                1001.into()

3161

1

));

3162

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

3163

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3164

1

                root_origin(),

3165

1

                1001.into(),

3166

1

3167

1

));

3168

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3169

1

                + crate::EXISTENTIAL_DEPOSIT;

3170

1

3171

1

            // Fill the tank

3172

1

            assert_ok!(ServicesPayment::purchase_credits(

3173

1

                origin_of(ALICE.into()),

3174

1

                1001.into(),

3175

1

                credits_1001

3176

1

));

3177

3178

            // Assignment should happen after 2 sessions

3179

1

            run_to_session(1u32);

3180

1

            let assignment = CollatorAssignment::collator_container_chain();

3181

1

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

3182

1

            run_to_session(2u32);

3183

1

            // Charlie and Dave should be assigned to para 1001

3184

1

            let assignment = CollatorAssignment::collator_container_chain();

3185

1

            assert_eq!(

3186

1

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

3187

1

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

3188

1

);

3189

3190

            // Simulate block inclusion from container chain 1001

3191

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

3192

1

            let slot: u64 = 5;

3193

1

            let s = ParaHeaderSproofBuilderItem {

3194

1

                para_id: 1001.into(),

3195

1

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

3196

1

                    parent_hash: Default::default(),

3197

1

                    number: 1,

3198

1

                    state_root: Default::default(),

3199

1

                    extrinsics_root: Default::default(),

3200

1

                    digest: sp_runtime::generic::Digest {

3201

1

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

3202

1

},

3203

1

}),

3204

1

};

3205

1

            sproof.items.push(s);

3206

1

            set_author_noting_inherent_data(sproof);

3207

1

3208

1

            run_block();

3209

1

3210

1

            // After this it should not be assigned anymore, since credits are not payable

3211

1

            run_to_session(4u32);

3212

1

            // Nobody should be assigned to para 1001

3213

1

            let assignment = CollatorAssignment::collator_container_chain();

3214

1

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

3215

1

});

3216

1

3217

3218

#[test]

3219

1

fn test_ed_plus_collator_assignment_credit_session_minus_1_purchase_fails() {

3220

1

    ExtBuilder::default()

3221

1

        .with_balances(vec![

3222

1

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

3223

1

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

3224

1

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

3225

1

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

3226

1

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

3227

1

])

3228

1

        .with_collators(vec![

3229

1

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

3230

1

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

3231

1

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

3232

1

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

3233

1

])

3234

1

        .build()

3235

1

        .execute_with(|| {

3236

1

            run_to_block(2);

3237

1

            // Assert current slot gets updated

3238

1

            assert_eq!(current_slot(), 1u64);

3239

1

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

3240

3241

            // Alice and Bob collate in our chain

3242

1

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

3243

1

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

3244

1

3245

1

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

3246

3247

1

            assert_ok!(Registrar::register(

3248

1

                origin_of(ALICE.into()),

3249

1

                1001.into(),

3250

1

                empty_genesis_data(),

3251

1

                None

3252

1

));

3253

1

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

3254

1

            assert_ok!(Registrar::mark_valid_for_collating(

3255

1

                root_origin(),

3256

1

                1001.into()

3257

1

));

3258

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

3259

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3260

1

                root_origin(),

3261

1

                1001.into(),

3262

1

3263

1

));

3264

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3265

1

                + crate::EXISTENTIAL_DEPOSIT

3266

1

                - 1;

3267

1

3268

1

            // Fill the tank

3269

1

            assert_ok!(ServicesPayment::purchase_credits(

3270

1

                origin_of(ALICE.into()),

3271

1

                1001.into(),

3272

1

                credits_1001

3273

1

));

3274

3275

            // Assignment should happen after 2 sessions

3276

1

            run_to_session(1u32);

3277

1

            let assignment = CollatorAssignment::collator_container_chain();

3278

1

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

3279

1

            run_to_session(2u32);

3280

1

            // Charlie and Dave should not be assigned to para 1001

3281

1

            let assignment = CollatorAssignment::collator_container_chain();

3282

1

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

3283

1

});

3284

1

3285

3286

#[test]

3287

1

fn test_collator_assignment_credits_with_purchase_can_be_combined() {

3288

1

    ExtBuilder::default()

3289

1

        .with_balances(vec![

3290

1

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

3291

1

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

3292

1

            (AccountId::from(BOB), 100_000 * UNIT),

3293

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3294

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3295

1

])

3296

1

        .with_collators(vec![

3297

1

            (AccountId::from(ALICE), 210 * UNIT),

3298

1

            (AccountId::from(BOB), 100 * UNIT),

3299

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3300

1

            (AccountId::from(DAVE), 100 * UNIT),

3301

1

])

3302

1

        .build()

3303

1

        .execute_with(|| {

3304

1

            run_to_block(2);

3305

1

            // Assert current slot gets updated

3306

1

            assert_eq!(current_slot(), 1u64);

3307

1

            assert!(current_author() == AccountId::from(BOB));

3308

3309

            // Alice and Bob collate in our chain

3310

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3311

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3312

1

3313

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3314

3315

1

            assert_ok!(Registrar::register(

3316

1

                origin_of(ALICE.into()),

3317

1

                1001.into(),

3318

1

                empty_genesis_data(),

3319

1

                None

3320

1

));

3321

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3322

1

            assert_ok!(Registrar::mark_valid_for_collating(

3323

1

                root_origin(),

3324

1

                1001.into()

3325

1

));

3326

3327

            // We assign one session to free credits

3328

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3329

1

                root_origin(),

3330

1

                1001.into(),

3331

1

3332

1

));

3333

            // We buy another session through the tank

3334

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3335

1

                + crate::EXISTENTIAL_DEPOSIT;

3336

1

3337

1

            // Fill the tank

3338

1

            assert_ok!(ServicesPayment::purchase_credits(

3339

1

                origin_of(ALICE.into()),

3340

1

                1001.into(),

3341

1

                credits_1001

3342

1

));

3343

3344

            // Assignment should happen after 2 sessions

3345

1

            run_to_session(1u32);

3346

1

            let assignment = CollatorAssignment::collator_container_chain();

3347

1

            assert!(assignment.container_chains.is_empty());

3348

1

            run_to_session(2u32);

3349

1

            // Charlie and Dave should be assigned to para 1001

3350

1

            let assignment = CollatorAssignment::collator_container_chain();

3351

1

            assert_eq!(

3352

1

                assignment.container_chains[&1001u32.into()],

3353

1

                vec![CHARLIE.into(), DAVE.into()]

3354

1

);

3355

1

});

3356

1

3357

3358

#[test]

3359

1

fn test_block_credits_and_collator_assignation_credits_through_tank() {

3360

1

    ExtBuilder::default()

3361

1

        .with_balances(vec![

3362

1

            // Alice gets 10k extra tokens for her mapping deposit

3363

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3364

1

            (AccountId::from(BOB), 100_000 * UNIT),

3365

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3366

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3367

1

])

3368

1

        .with_collators(vec![

3369

1

            (AccountId::from(ALICE), 210 * UNIT),

3370

1

            (AccountId::from(BOB), 100 * UNIT),

3371

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3372

1

            (AccountId::from(DAVE), 100 * UNIT),

3373

1

])

3374

1

        .build()

3375

1

        .execute_with(|| {

3376

1

            run_to_block(2);

3377

1

            // Assert current slot gets updated

3378

1

            assert_eq!(current_slot(), 1u64);

3379

1

            assert!(current_author() == AccountId::from(BOB));

3380

3381

            // Alice and Bob collate in our chain

3382

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3383

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3384

1

3385

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3386

3387

1

            assert_ok!(Registrar::register(

3388

1

                origin_of(ALICE.into()),

3389

1

                1001.into(),

3390

1

                empty_genesis_data(),

3391

1

                None

3392

1

));

3393

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3394

1

            assert_ok!(Registrar::mark_valid_for_collating(

3395

1

                root_origin(),

3396

1

                1001.into()

3397

1

));

3398

3399

            // We make all free credits 0

3400

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3401

1

                root_origin(),

3402

1

                1001.into(),

3403

1

3404

1

));

3405

1

            assert_ok!(ServicesPayment::set_block_production_credits(

3406

1

                root_origin(),

3407

1

                1001.into(),

3408

1

3409

1

));

3410

3411

            // We buy 2 sessions through tank

3412

1

            let collator_assignation_credits =

3413

1

                collator_assignment_credits_to_required_balance(2, 1001.into());

3414

1

            let block_production_credits =

3415

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into());

3416

1

3417

1

            // Fill the tank

3418

1

            assert_ok!(ServicesPayment::purchase_credits(

3419

1

                origin_of(ALICE.into()),

3420

1

                1001.into(),

3421

1

                collator_assignation_credits

3422

1

                    + block_production_credits

3423

1

                    + crate::EXISTENTIAL_DEPOSIT

3424

1

));

3425

3426

            // Assignment should happen after 2 sessions

3427

1

            run_to_session(1u32);

3428

1

            let assignment = CollatorAssignment::collator_container_chain();

3429

1

            assert!(assignment.container_chains.is_empty());

3430

1

            run_to_session(2u32);

3431

1

            // Charlie and Dave should be assigned to para 1001

3432

1

            let assignment = CollatorAssignment::collator_container_chain();

3433

1

            assert_eq!(

3434

1

                assignment.container_chains[&1001u32.into()],

3435

1

                vec![CHARLIE.into(), DAVE.into()]

3436

1

);

3437

3438

            // After this it should not be assigned anymore, since credits are not payable

3439

1

            run_to_session(4u32);

3440

1

            // Nobody should be assigned to para 1001

3441

1

            let assignment = CollatorAssignment::collator_container_chain();

3442

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

3443

1

});

3444

1

3445

3446

#[test]

3447

1

fn test_migration_services_collator_assignment_payment() {

3448

1

    ExtBuilder::default().build().execute_with(|| {

3449

1

        // Register a new parachain with no credits

3450

1

        assert_ok!(Registrar::register(

3451

1

            origin_of(ALICE.into()),

3452

1

            1001.into(),

3453

1

            empty_genesis_data(),

3454

1

            None

3455

1

));

3456

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3457

1

        assert_ok!(Registrar::mark_valid_for_collating(

3458

1

            root_origin(),

3459

1

            1001.into()

3460

1

));

3461

        // Register another parachain with no credits, do not mark this as valid for collation

3462

1

        assert_ok!(Registrar::register(

3463

1

            origin_of(ALICE.into()),

3464

1

            1002.into(),

3465

1

            empty_genesis_data(),

3466

1

            None

3467

1

));

3468

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1002.into());

3469

1

        assert_ok!(Registrar::mark_valid_for_collating(

3470

1

            root_origin(),

3471

1

            1002.into()

3472

1

));

3473

3474

        // Need to reset credits to 0 because now parachains are given free credits on register

3475

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

3476

1

            root_origin(),

3477

1

            1001.into(),

3478

1

3479

1

));

3480

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

3481

1

            root_origin(),

3482

1

            1002.into(),

3483

1

3484

1

));

3485

3486

1

        let credits_1001 =

3487

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

3488

1

                .unwrap_or_default();

3489

1

        assert_eq!(credits_1001, 0);

3490

1

        let credits_1002 =

3491

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

3492

1

                .unwrap_or_default();

3493

1

        assert_eq!(credits_1002, 0);

3494

3495

        // Apply migration

3496

1

        let migration =

3497

1

            MigrateServicesPaymentAddCollatorAssignmentCredits::<Runtime>(Default::default());

3498

1

        migration.migrate(Default::default());

3499

1

3500

1

        // Both parachains have been given credits

3501

1

        let credits_1001 =

3502

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

3503

1

                .unwrap_or_default();

3504

1

        assert_eq!(credits_1001, crate::FreeCollatorAssignmentCredits::get());

3505

1

        let credits_1002 =

3506

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

3507

1

                .unwrap_or_default();

3508

1

        assert_eq!(credits_1002, crate::FreeCollatorAssignmentCredits::get());

3509

1

});

3510

1

3511

3512

#[test]

3513

1

fn test_max_collators_uses_pending_value() {

3514

1

    // Start with max_collators = 100, and collators_per_container = 2

3515

1

    // Set max_collators = 2, and collators_per_container = 3

3516

1

    // It should be impossible to have more than 2 collators per container at any point in time

3517

1

    ExtBuilder::default()

3518

1

        .with_balances(vec![

3519

1

            // Alice gets 10k extra tokens for her mapping deposit

3520

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3521

1

            (AccountId::from(BOB), 100_000 * UNIT),

3522

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3523

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3524

1

])

3525

1

        .with_collators(vec![

3526

1

            (AccountId::from(ALICE), 210 * UNIT),

3527

1

            (AccountId::from(BOB), 100 * UNIT),

3528

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3529

1

            (AccountId::from(DAVE), 100 * UNIT),

3530

1

])

3531

1

        .with_empty_parachains(vec![1001])

3532

1

        .with_config(pallet_configuration::HostConfiguration {

3533

1

            max_collators: 100,

3534

1

            min_orchestrator_collators: 1,

3535

1

            max_orchestrator_collators: 1,

3536

1

            collators_per_container: 2,

3537

1

            full_rotation_period: 24,

3538

1

            ..Default::default()

3539

1

})

3540

1

        .build()

3541

1

        .execute_with(|| {

3542

1

            run_to_block(2);

3543

1

3544

1

            // Initial assignment: 1 collator in orchestrator chain and 2 collators in container 1001

3545

1

            let assignment = CollatorAssignment::collator_container_chain();

3546

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 2);

3547

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

3548

3549

1

            assert_ok!(Configuration::set_max_collators(root_origin(), 2));

3550

1

            assert_ok!(Configuration::set_collators_per_container(root_origin(), 3));

3551

3552

            // Check invariant for all intermediate assignments. We set collators_per_container = 3

3553

            // but we also set max_collators = 2, so no collators will be assigned to container

3554

            // chains after the change is applied.

3555

5

            for session in 1..=4 {

3556

4

                run_to_session(session);

3557

4

3558

4

                let assignment = CollatorAssignment::collator_container_chain();

3559

4

                assert!(

3560

4

                    assignment.container_chains[&1001u32.into()].len() <= 2,

3561

                    "session {}: {} collators assigned to container chain 1001",

3562

                    session,

3563

                    assignment.container_chains[&1001u32.into()].len()

3564

);

3565

3566

3567

            // Final assignment: because max_collators = 2, there are only 2 collators, one in

3568

            // orchestrator chain, and the other one idle

3569

1

            let assignment = CollatorAssignment::collator_container_chain();

3570

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 0);

3571

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

3572

1

});

3573

1

3574

3575

#[test]

3576

1

fn test_slow_adjusting_multiplier_changes_in_response_to_consumed_weight() {

3577

1

    ExtBuilder::default()

3578

1

        .with_collators(vec![

3579

1

            (AccountId::from(ALICE), 210 * UNIT),

3580

1

            (AccountId::from(BOB), 100 * UNIT),

3581

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3582

1

            (AccountId::from(DAVE), 100 * UNIT),

3583

1

])

3584

1

        .build()

3585

1

        .execute_with(|| {

3586

1

            end_block();

3587

1

            // If the block is full, the multiplier increases

3588

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

3589

1

            start_block();

3590

1

            let max_block_weights = crate::RuntimeBlockWeights::get();

3591

1

            frame_support::storage::unhashed::put(

3592

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

3593

3

                &ConsumedWeight::new(|class| {

3594

3

                    max_block_weights

3595

3

                        .get(class)

3596

3

                        .max_total

3597

3

                        .unwrap_or(Weight::MAX)

3598

3

}),

3599

1

);

3600

1

            end_block();

3601

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

3602

1

            assert!(current_multiplier > before_multiplier);

3603

3604

            // If the block is empty, the multiplier decreases

3605

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

3606

1

            start_block();

3607

1

            frame_support::storage::unhashed::put(

3608

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

3609

3

                &ConsumedWeight::new(|_class| Weight::zero()),

3610

1

);

3611

1

            end_block();

3612

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

3613

1

            assert!(current_multiplier < before_multiplier);

3614

1

});

3615

1

3616

3617

#[test]

3618

1

fn test_collator_assignment_tip_priority_on_congestion() {

3619

1

    ExtBuilder::default()

3620

1

        .with_balances(vec![

3621

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3622

1

            (AccountId::from(BOB), 100_000 * UNIT),

3623

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3624

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3625

1

])

3626

1

        .with_collators(vec![

3627

1

            (AccountId::from(ALICE), 210 * UNIT),

3628

1

            (AccountId::from(BOB), 100 * UNIT),

3629

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3630

1

            (AccountId::from(DAVE), 100 * UNIT),

3631

1

])

3632

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3633

1

        .build()

3634

1

        .execute_with(|| {

3635

1

            let para_id = 1003u32;

3636

1

            let tank_funds = 100 * UNIT;

3637

1

            let max_tip = 1 * UNIT;

3638

1

3639

1

            assert_eq!(

3640

1

                CollatorAssignment::collator_container_chain().container_chains[&1003u32.into()]

3641

1

                    .len(),

3642

1

3643

1

);

3644

3645

            // Send funds to tank

3646

1

            assert_ok!(ServicesPayment::purchase_credits(

3647

1

                origin_of(ALICE.into()),

3648

1

                para_id.into(),

3649

1

                tank_funds,

3650

1

));

3651

3652

            // Set tip for 1003

3653

1

            assert_ok!(ServicesPayment::set_max_tip(

3654

1

                root_origin(),

3655

1

                para_id.into(),

3656

1

                Some(max_tip),

3657

1

));

3658

3659

1

            run_to_session(2);

3660

1

            assert_eq!(

3661

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

3662

1

                    .len(),

3663

1

2,

3664

1

);

3665

1

});

3666

1

3667

3668

#[test]

3669

1

fn test_collator_assignment_tip_charged_on_congestion() {

3670

1

    ExtBuilder::default()

3671

1

        .with_balances(vec![

3672

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3673

1

            (AccountId::from(BOB), 100_000 * UNIT),

3674

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3675

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3676

1

])

3677

1

        .with_collators(vec![

3678

1

            (AccountId::from(ALICE), 210 * UNIT),

3679

1

            (AccountId::from(BOB), 100 * UNIT),

3680

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3681

1

            (AccountId::from(DAVE), 100 * UNIT),

3682

1

])

3683

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3684

1

        .build()

3685

1

        .execute_with(|| {

3686

1

            let tank_funds = 100 * UNIT;

3687

1

            let max_tip = 1 * UNIT;

3688

1

            let para_id = 1003u32;

3689

1

3690

1

            // Send funds to tank

3691

1

            assert_ok!(ServicesPayment::purchase_credits(

3692

1

                origin_of(ALICE.into()),

3693

1

                para_id.into(),

3694

1

                tank_funds,

3695

1

));

3696

3697

            // Set tip for para_id

3698

1

            assert_ok!(ServicesPayment::set_max_tip(

3699

1

                root_origin(),

3700

1

                para_id.into(),

3701

1

                Some(max_tip),

3702

1

));

3703

3704

1

            run_to_session(1);

3705

1

            assert_eq!(

3706

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id.into())),

3707

1

                tank_funds - max_tip,

3708

1

);

3709

1

});

3710

1

3711

3712

#[test]

3713

1

fn test_collator_assignment_tip_not_assigned_on_insufficient_balance() {

3714

1

    ExtBuilder::default()

3715

1

        .with_balances(vec![

3716

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3717

1

            (AccountId::from(BOB), 100_000 * UNIT),

3718

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3719

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3720

1

])

3721

1

        .with_collators(vec![

3722

1

            (AccountId::from(ALICE), 210 * UNIT),

3723

1

            (AccountId::from(BOB), 100 * UNIT),

3724

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3725

1

            (AccountId::from(DAVE), 100 * UNIT),

3726

1

])

3727

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3728

1

        .build()

3729

1

        .execute_with(|| {

3730

1

            let tank_funds = 1 * UNIT;

3731

1

            let max_tip = 1 * UNIT;

3732

1

            let para_id = 1003u32;

3733

1

3734

1

            // Send insufficient funds to tank for tip for 2 sessions

3735

1

            assert_ok!(ServicesPayment::purchase_credits(

3736

1

                origin_of(ALICE.into()),

3737

1

                para_id.into(),

3738

1

                tank_funds,

3739

1

));

3740

3741

            // Set tip for para_id

3742

1

            assert_ok!(ServicesPayment::set_max_tip(

3743

1

                root_origin(),

3744

1

                para_id.into(),

3745

1

                Some(max_tip),

3746

1

));

3747

3748

1

            run_to_session(1);

3749

1

            assert_eq!(

3750

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

3751

1

                    .len(),

3752

1

3753

1

);

3754

1

});

3755

1

3756

3757

#[test]

3758

1

fn test_collator_assignment_tip_only_charge_willing_paras() {

3759

1

    ExtBuilder::default()

3760

1

        .with_balances(vec![

3761

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3762

1

            (AccountId::from(BOB), 100_000 * UNIT),

3763

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3764

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3765

1

            (AccountId::from(EVE), 100_000 * UNIT),

3766

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

3767

1

])

3768

1

        .with_collators(vec![

3769

1

            (AccountId::from(ALICE), 210 * UNIT),

3770

1

            (AccountId::from(BOB), 100 * UNIT),

3771

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3772

1

            (AccountId::from(DAVE), 100 * UNIT),

3773

1

            (AccountId::from(EVE), 100 * UNIT),

3774

1

            (AccountId::from(FERDIE), 100 * UNIT),

3775

1

])

3776

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3777

1

        .build()

3778

1

        .execute_with(|| {

3779

1

            let tank_funds = 100 * UNIT;

3780

1

            let max_tip = 1 * UNIT;

3781

1

            let para_id_with_tip = 1003u32;

3782

1

            let para_id_without_tip = 1001u32;

3783

1

3784

1

            // Send funds to tank to both paras

3785

1

            assert_ok!(ServicesPayment::purchase_credits(

3786

1

                origin_of(ALICE.into()),

3787

1

                para_id_with_tip.into(),

3788

1

                tank_funds,

3789

1

));

3790

1

            assert_ok!(ServicesPayment::purchase_credits(

3791

1

                origin_of(ALICE.into()),

3792

1

                para_id_without_tip.into(),

3793

1

                tank_funds,

3794

1

));

3795

3796

            // Only set tip for 1003

3797

1

            assert_ok!(ServicesPayment::set_max_tip(

3798

1

                root_origin(),

3799

1

                para_id_with_tip.into(),

3800

1

                Some(max_tip),

3801

1

));

3802

3803

1

            run_to_session(2);

3804

1

3805

1

            let assignment = CollatorAssignment::collator_container_chain().container_chains;

3806

1

3807

1

            // 2 out of the 3 paras should have collators assigned, with one paying tip to get

3808

1

            // prioritized, and the other selected at random that should not be charged any tips

3809

1

            assert_eq!(assignment[&para_id_with_tip.into()].len(), 2);

3810

1

            assert_eq!(

3811

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_with_tip.into())),

3812

1

                tank_funds - max_tip * 2,

3813

1

);

3814

3815

1

            assert_eq!(assignment[&para_id_without_tip.into()].len(), 2);

3816

1

            assert_eq!(

3817

1

                Balances::usable_balance(ServicesPayment::parachain_tank(

3818

1

                    para_id_without_tip.into()

3819

1

)),

3820

1

                tank_funds,

3821

1

);

3822

1

});

3823

1

3824

3825

#[test]

3826

1

fn test_collator_assignment_tip_withdraw_min_tip() {

3827

1

    ExtBuilder::default()

3828

1

        .with_balances(vec![

3829

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3830

1

            (AccountId::from(BOB), 100_000 * UNIT),

3831

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3832

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3833

1

            (AccountId::from(EVE), 100_000 * UNIT),

3834

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

3835

1

])

3836

1

        .with_collators(vec![

3837

1

            (AccountId::from(ALICE), 210 * UNIT),

3838

1

            (AccountId::from(BOB), 100 * UNIT),

3839

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3840

1

            (AccountId::from(DAVE), 100 * UNIT),

3841

1

            (AccountId::from(EVE), 100 * UNIT),

3842

1

            (AccountId::from(FERDIE), 100 * UNIT),

3843

1

])

3844

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3845

1

        .build()

3846

1

        .execute_with(|| {

3847

1

            let tank_funds = 100 * UNIT;

3848

1

            let max_tip_1003 = 3 * UNIT;

3849

1

            let max_tip_1002 = 2 * UNIT;

3850

1

            let para_id_1003 = 1003u32;

3851

1

            let para_id_1002 = 1002u32;

3852

1

3853

1

            // Send funds to tank to both paras

3854

1

            assert_ok!(ServicesPayment::purchase_credits(

3855

1

                origin_of(ALICE.into()),

3856

1

                para_id_1003.into(),

3857

1

                tank_funds,

3858

1

));

3859

1

            assert_ok!(ServicesPayment::purchase_credits(

3860

1

                origin_of(ALICE.into()),

3861

1

                para_id_1002.into(),

3862

1

                tank_funds,

3863

1

));

3864

3865

            // Set tips

3866

1

            assert_ok!(ServicesPayment::set_max_tip(

3867

1

                root_origin(),

3868

1

                para_id_1003.into(),

3869

1

                Some(max_tip_1003),

3870

1

));

3871

1

            assert_ok!(ServicesPayment::set_max_tip(

3872

1

                root_origin(),

3873

1

                para_id_1002.into(),

3874

1

                Some(max_tip_1002),

3875

1

));

3876

3877

1

            run_to_session(2);

3878

1

3879

1

            assert_eq!(

3880

1

                CollatorAssignment::collator_container_chain().container_chains

3881

1

                    [&para_id_1003.into()]

3882

1

                    .len(),

3883

1

3884

1

);

3885

1

            assert_eq!(

3886

1

                CollatorAssignment::collator_container_chain().container_chains

3887

1

                    [&para_id_1002.into()]

3888

1

                    .len(),

3889

1

3890

1

);

3891

3892

            // Should have withdrawn the lowest tip from both paras

3893

1

            assert_eq!(

3894

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1003.into())),

3895

1

                tank_funds - max_tip_1002 * 2,

3896

1

);

3897

3898

1

            assert_eq!(

3899

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1002.into())),

3900

1

                tank_funds - max_tip_1002 * 2,

3901

1

);

3902

1

});

3903

1

3904

3905

#[test]

3906

1

fn test_migration_data_preservers_assignments() {

3907

1

    ExtBuilder::default().build().execute_with(|| {

3908

        use {

3909

            crate::{MaxAssignmentsPerParaId, MaxNodeUrlLen},

3910

            frame_support::{

3911

                migration::{have_storage_value, put_storage_value},

3912

                Blake2_128Concat, StorageHasher,

3913

},

3914

            pallet_data_preservers::{ParaIdsFilter, Profile, ProfileMode, RegisteredProfile},

3915

            sp_runtime::BoundedBTreeSet,

3916

            sp_std::collections::btree_set::BTreeSet,

3917

            tanssi_runtime_common::migrations::DataPreserversAssignmentsMigration,

3918

};

3919

3920

        macro_rules! bset {

3921

            ( $($value:expr),* $(,)? ) => {

3922

3923

                    let mut set = BoundedBTreeSet::new();

3924

$(

3925

                        set.try_insert($value).expect("max bound reached");

3926

)*

3927

set

3928

3929

3930

3931

3932

        macro_rules! set {

3933

            ( $($value:expr),* $(,)? ) => {

3934

3935

                    let mut set = BTreeSet::new();

3936

$(

3937

                        set.insert($value);

3938

)*

3939

set

3940

3941

3942

3943

3944

1

        let account = AccountId::from([0u8; 32]);

3945

1

        let free_request = crate::PreserversAssignementPaymentRequest::Free;

3946

1

        let free_witness = crate::PreserversAssignementPaymentWitness::Free;

3947

1

3948

1

        let pallet_prefix: &[u8] = b"DataPreservers";

3949

1

        let storage_item_prefix: &[u8] = b"BootNodes";

3950

1

3951

1

        // Register 2 parachains

3952

1

        assert_ok!(Registrar::register(

3953

1

            origin_of(ALICE.into()),

3954

1

            1001.into(),

3955

1

            empty_genesis_data(),

3956

1

            None

3957

1

));

3958

1

        assert_ok!(Registrar::register(

3959

1

            origin_of(BOB.into()),

3960

1

            1002.into(),

3961

1

            empty_genesis_data(),

3962

1

            None

3963

1

));

3964

3965

        // Set bootnodes in old storage

3966

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

3967

1

            b"alpha".to_vec().try_into().unwrap(),

3968

1

            b"beta".to_vec().try_into().unwrap(),

3969

1

3970

1

        .try_into()

3971

1

        .unwrap();

3972

1

        put_storage_value(

3973

1

            pallet_prefix,

3974

1

            storage_item_prefix,

3975

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode()),

3976

1

            bootnodes,

3977

1

);

3978

1

3979

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

3980

1

            b"delta".to_vec().try_into().unwrap(),

3981

1

            b"gamma".to_vec().try_into().unwrap(),

3982

1

3983

1

        .try_into()

3984

1

        .unwrap();

3985

1

        put_storage_value(

3986

1

            pallet_prefix,

3987

1

            storage_item_prefix,

3988

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode()),

3989

1

            bootnodes,

3990

1

);

3991

1

3992

1

        // Apply migration

3993

1

        let migration = DataPreserversAssignmentsMigration::<Runtime>(Default::default());

3994

1

        migration.migrate(Default::default());

3995

1

3996

1

        // Check old storage is empty

3997

1

        assert!(!have_storage_value(

3998

1

            pallet_prefix,

3999

1

            storage_item_prefix,

4000

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode())

4001

1

));

4002

1

        assert!(!have_storage_value(

4003

1

            pallet_prefix,

4004

1

            storage_item_prefix,

4005

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode())

4006

1

));

4007

4008

        // Check new storage

4009

1

        assert_eq!(

4010

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1001)).into_inner(),

4011

1

            set![0, 1]

4012

1

);

4013

1

        assert_eq!(

4014

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1002)).into_inner(),

4015

1

            set![2, 3]

4016

1

);

4017

1

        assert_eq!(pallet_data_preservers::NextProfileId::<Runtime>::get(), 4);

4018

1

        assert_eq!(

4019

1

            pallet_data_preservers::Profiles::<Runtime>::get(0),

4020

1

            Some(RegisteredProfile {

4021

1

                account: account.clone(),

4022

1

                deposit: 0,

4023

1

                assignment: Some((1001.into(), free_witness)),

4024

1

                profile: Profile {

4025

1

                    url: b"alpha".to_vec().try_into().unwrap(),

4026

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

4027

1

                    mode: ProfileMode::Bootnode,

4028

1

                    assignment_request: free_request,

4029

1

4030

1

})

4031

1

);

4032

1

        assert_eq!(

4033

1

            pallet_data_preservers::Profiles::<Runtime>::get(1),

4034

1

            Some(RegisteredProfile {

4035

1

                account: account.clone(),

4036

1

                deposit: 0,

4037

1

                assignment: Some((1001.into(), free_witness)),

4038

1

                profile: Profile {

4039

1

                    url: b"beta".to_vec().try_into().unwrap(),

4040

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

4041

1

                    mode: ProfileMode::Bootnode,

4042

1

                    assignment_request: free_request,

4043

1

4044

1

})

4045

1

);

4046

1

        assert_eq!(

4047

1

            pallet_data_preservers::Profiles::<Runtime>::get(2),

4048

1

            Some(RegisteredProfile {

4049

1

                account: account.clone(),

4050

1

                deposit: 0,

4051

1

                assignment: Some((1002.into(), free_witness)),

4052

1

                profile: Profile {

4053

1

                    url: b"delta".to_vec().try_into().unwrap(),

4054

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

4055

1

                    mode: ProfileMode::Bootnode,

4056

1

                    assignment_request: free_request,

4057

1

4058

1

})

4059

1

);

4060

1

        assert_eq!(

4061

1

            pallet_data_preservers::Profiles::<Runtime>::get(3),

4062

1

            Some(RegisteredProfile {

4063

1

                account: account.clone(),

4064

1

                deposit: 0,

4065

1

                assignment: Some((1002.into(), free_witness)),

4066

1

                profile: Profile {

4067

1

                    url: b"gamma".to_vec().try_into().unwrap(),

4068

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

4069

1

                    mode: ProfileMode::Bootnode,

4070

1

                    assignment_request: free_request,

4071

1

4072

1

})

4073

1

);

4074

1

})

4075

1

4076

4077

#[test]

4078

1

fn test_migration_registrar_reserves_to_hold() {

4079

1

    ExtBuilder::default()

4080

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

4081

1

        .build()

4082

1

        .execute_with(|| {

4083

            use {

4084

                frame_support::traits::{fungible::InspectHold, ReservableCurrency},

4085

                pallet_registrar::DepositInfo,

4086

                tanssi_runtime_common::migrations::RegistrarReserveToHoldMigration,

4087

};

4088

4089

1

            let deposit: Balance = 100 * UNIT;

4090

1

            let account: AccountId = DAVE.into();

4091

1

4092

1

            assert_ok!(Balances::reserve(&account, deposit));

4093

4094

1

            pallet_registrar::RegistrarDeposit::<Runtime>::insert(

4095

1

                ParaId::from(1001),

4096

1

                DepositInfo {

4097

1

                    creator: account.clone(),

4098

1

                    deposit,

4099

1

},

4100

1

);

4101

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

4102

            // Apply migration

4103

1

            let migration = RegistrarReserveToHoldMigration::<Runtime>(Default::default());

4104

1

            migration.migrate(Default::default());

4105

1

4106

1

            // Holds also count as reserved balance, so the total reserved amount

4107

1

            // shouldn't change after the migration

4108

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

4109

4110

1

            assert_eq!(

4111

1

                Balances::balance_on_hold(

4112

1

                    &pallet_registrar::HoldReason::RegistrarDeposit.into(),

4113

1

                    &account

4114

1

),

4115

1

                deposit

4116

1

);

4117

1

})

4118

1

4119

4120

#[test]

4121

1

fn test_container_deregister_unassign_data_preserver() {

4122

1

    ExtBuilder::default()

4123

1

        .with_balances(vec![

4124

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4125

1

            (AccountId::from(BOB), 100_000 * UNIT),

4126

1

])

4127

1

        .build()

4128

1

        .execute_with(|| {

4129

            use pallet_data_preservers::{

4130

                AssignerParameterOf, ParaIdsFilter, Profile, ProfileMode, ProviderRequestOf,

4131

};

4132

4133

1

            let profile = Profile {

4134

1

                url: b"test".to_vec().try_into().unwrap(),

4135

1

                para_ids: ParaIdsFilter::AnyParaId,

4136

1

                mode: ProfileMode::Bootnode,

4137

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

4138

1

};

4139

1

4140

1

            let para_id = ParaId::from(1002);

4141

1

            let profile_id = 0u64;

4142

1

4143

1

            assert_ok!(Registrar::register(

4144

1

                origin_of(ALICE.into()),

4145

1

                para_id,

4146

1

                empty_genesis_data(),

4147

1

                None

4148

1

));

4149

4150

1

            assert_ok!(DataPreservers::create_profile(

4151

1

                origin_of(BOB.into()),

4152

1

                profile.clone(),

4153

1

));

4154

4155

            // Start assignment

4156

1

            assert_ok!(DataPreservers::start_assignment(

4157

1

                origin_of(ALICE.into()),

4158

1

                profile_id,

4159

1

                para_id,

4160

1

                AssignerParameterOf::<Runtime>::Free

4161

1

));

4162

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&0u64));

4163

4164

            // Deregister from Registrar

4165

1

            assert_ok!(Registrar::deregister(root_origin(), para_id), ());

4166

4167

            // Check DataPreserver assignment has been cleared

4168

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).is_empty());

4169

1

});

4170

1