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

21

    alloc::vec,

22

    cumulus_primitives_core::{ParaId, Weight},

23

    dp_consensus::runtime_decl_for_tanssi_authority_assignment_api::TanssiAuthorityAssignmentApiV1,

24

    dp_core::well_known_keys,

25

    frame_support::{assert_err, assert_noop, assert_ok, BoundedVec},

26

    frame_system::ConsumedWeight,

27

    nimbus_primitives::NIMBUS_KEY_ID,

28

    pallet_author_noting_runtime_api::runtime_decl_for_author_noting_api::AuthorNotingApi,

29

    pallet_migrations::Migration,

30

    pallet_registrar_runtime_api::{

31

        runtime_decl_for_registrar_api::RegistrarApi, ContainerChainGenesisData,

32

},

33

    pallet_stream_payment::StreamConfig,

34

    parity_scale_codec::Encode,

35

    sp_consensus_aura::AURA_ENGINE_ID,

36

    sp_core::Get,

37

    sp_runtime::{

38

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

39

        DigestItem,

40

},

41

    tanssi_runtime_common::migrations::MigrateServicesPaymentAddCollatorAssignmentCredits,

42

    test_relay_sproof_builder::{HeaderAs, ParaHeaderSproofBuilder, ParaHeaderSproofBuilderItem},

43

    tp_stream_payment_common::{

44

        AssetId as StreamPaymentAssetId, TimeUnit as StreamPaymentTimeUnit,

45

},

46

    tp_traits::{ContainerChainBlockInfo, SlotFrequency},

47

};

48

49

20

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

50

    use pallet_data_preservers::{NodeType, ParaIdsFilter, Profile};

51

52

20

    let profile = Profile {

53

20

        bootnode_url: Some(

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

),

59

20

        direct_rpc_urls: Default::default(),

60

20

        proxy_rpc_urls: Default::default(),

61

20

        para_ids: ParaIdsFilter::AnyParaId,

62

20

        node_type: NodeType::Substrate,

63

20

        additional_info: Default::default(),

64

20

        assignment_request: tp_data_preservers_common::ProviderRequest::Free,

65

20

};

66

67

20

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

68

20

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

69

20

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

70

20

        .expect("profile create to succeed");

71

72

20

    DataPreservers::start_assignment(

73

20

        para_manager,

74

20

        profile_id,

75

20

        para_id,

76

20

        tp_data_preservers_common::AssignerExtra::Free,

77

78

20

    .expect("assignement to work");

79

80

20

    assert!(

81

20

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

82

        "profile should be correctly assigned"

83

);

84

20

85

86

#[test]

87

1

fn genesis_balances() {

88

1

    ExtBuilder::default()

89

1

        .with_balances(vec![

90

1

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

91

1

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

92

1

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

93

1

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

94

1

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

95

1

])

96

1

        .with_collators(vec![

97

1

            // Remove ALICE and BOB from collators

98

1

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

99

1

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

100

1

])

101

1

        .build()

102

1

        .execute_with(|| {

103

1

            assert_eq!(

104

1

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

105

                210_000 * UNIT,

106

);

107

1

            assert_eq!(

108

1

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

109

                100_000 * UNIT,

110

);

111

1

});

112

1

113

114

#[test]

115

1

fn genesis_para_registrar() {

116

1

    ExtBuilder::default()

117

1

        .with_empty_parachains(vec![1001, 1002])

118

1

        .build()

119

1

        .execute_with(|| {

120

1

            assert_eq!(

121

1

                Registrar::registered_para_ids(),

122

1

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

123

);

124

1

});

125

1

126

127

#[test]

128

1

fn genesis_para_registrar_deregister() {

129

1

    ExtBuilder::default()

130

1

        .with_empty_parachains(vec![1001, 1002])

131

1

        .build()

132

1

        .execute_with(|| {

133

1

            assert_eq!(

134

1

                Registrar::registered_para_ids(),

135

1

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

136

);

137

138

1

            run_to_block(2);

139

1

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

140

141

            // Pending

142

1

            assert_eq!(

143

1

                Registrar::pending_registered_para_ids(),

144

1

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

145

);

146

147

1

            run_to_session(1);

148

1

            assert_eq!(

149

1

                Registrar::pending_registered_para_ids(),

150

1

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

151

);

152

1

            assert_eq!(

153

1

                Registrar::registered_para_ids(),

154

1

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

155

);

156

157

1

            run_to_session(2);

158

1

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

159

1

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

160

1

});

161

1

162

163

#[test]

164

1

fn genesis_para_registrar_runtime_api() {

165

1

    ExtBuilder::default()

166

1

        .with_empty_parachains(vec![1001, 1002])

167

1

        .build()

168

1

        .execute_with(|| {

169

1

            assert_eq!(

170

1

                Registrar::registered_para_ids(),

171

1

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

172

);

173

1

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

174

175

1

            run_to_block(2);

176

1

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

177

1

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

178

179

1

            run_to_session(1);

180

1

            assert_eq!(

181

1

                Registrar::registered_para_ids(),

182

1

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

183

);

184

1

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

185

186

1

            run_to_session(2);

187

1

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

188

1

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

189

1

});

190

1

191

192

#[test]

193

1

fn genesis_para_registrar_container_chain_genesis_data_runtime_api() {

194

1

    let genesis_data_1001 = empty_genesis_data();

195

1

    let genesis_data_1002 = ContainerChainGenesisData {

196

1

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

197

1

        name: Default::default(),

198

1

        id: Default::default(),

199

1

        fork_id: Default::default(),

200

1

        extensions: BoundedVec::try_from(vec![]).unwrap(),

201

1

        properties: Default::default(),

202

1

};

203

1

    ExtBuilder::default()

204

1

        .with_para_ids(vec![

205

1

            ParaRegistrationParams {

206

1

                para_id: 1001,

207

1

                genesis_data: genesis_data_1001.clone(),

208

1

                block_production_credits: u32::MAX,

209

1

                collator_assignment_credits: u32::MAX,

210

1

                parathread_params: None,

211

1

            },ParaRegistrationParams {

212

1

                para_id: 1002,

213

1

                genesis_data: genesis_data_1002.clone(),

214

1

                block_production_credits: u32::MAX,

215

1

                collator_assignment_credits: u32::MAX,

216

1

                parathread_params: None,

217

1

            },        ])

218

1

        .build()

219

1

        .execute_with(|| {

220

1

            assert_eq!(

221

1

                Registrar::registered_para_ids(),

222

1

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

223

);

224

1

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

225

226

1

            assert_eq!(

227

1

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

228

1

                Some(&genesis_data_1001)

229

);

230

1

            assert_eq!(

231

1

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

232

1

                Some(&genesis_data_1002)

233

);

234

1

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

235

236

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

237

            // with id 100

238

            // TODO: where is that 100 defined?

239

1

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

240

241

1

            run_to_block(2);

242

1

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

243

244

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

245

246

1

            let genesis_data_1003 = ContainerChainGenesisData {

247

1

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

248

1

                name: Default::default(),

249

1

                id: Default::default(),

250

1

                fork_id: Default::default(),

251

1

                extensions: BoundedVec::try_from(vec![]).unwrap(),

252

1

                properties: Default::default(),

253

1

};

254

1

            assert_ok!(

255

1

                Registrar::register(

256

1

                    origin_of(ALICE.into()),

257

1

                    1003.into(),

258

1

                    genesis_data_1003.clone(),

259

1

                    None

260

),

261

()

262

);

263

264

            // Registered container chains are inserted immediately

265

1

            assert_eq!(

266

1

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

267

1

                Some(&genesis_data_1003)

268

);

269

270

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

271

1

            run_to_session(2u32);

272

1

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

273

1

});

274

1

275

276

#[test]

277

1

fn test_author_collation_aura() {

278

1

    ExtBuilder::default()

279

1

        .with_empty_parachains(vec![1001, 1002])

280

1

        .build()

281

1

        .execute_with(|| {

282

1

            run_to_block(5);

283

            // Assert current slot gets updated

284

1

            assert_eq!(current_slot(), 4u64);

285

            // slot 4, alice

286

1

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

287

288

1

            run_to_block(6);

289

290

1

            assert_eq!(current_slot(), 5u64);

291

            // slot 5, bob

292

1

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

293

1

});

294

1

295

296

#[test]

297

1

fn test_author_collation_aura_change_of_authorities_on_session() {

298

1

    ExtBuilder::default()

299

1

        .with_balances(vec![

300

1

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

301

1

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

302

1

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

303

1

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

304

1

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

305

1

])

306

1

        .with_empty_parachains(vec![1001, 1002])

307

1

        .build()

308

1

        .execute_with(|| {

309

1

            run_to_block(2);

310

            // Assert current slot gets updated

311

1

            assert_eq!(current_slot(), 1u64);

312

1

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

313

314

            // We change invulnerables

315

            // We first need to set the keys

316

1

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

317

1

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

318

319

1

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

320

1

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

321

322

            // Set CHARLIE and DAVE keys

323

1

            assert_ok!(Session::set_keys(

324

1

                origin_of(CHARLIE.into()),

325

1

                crate::SessionKeys {

326

1

                    nimbus: charlie_id.clone(),

327

1

},

328

1

                vec![]

329

));

330

1

            assert_ok!(Session::set_keys(

331

1

                origin_of(DAVE.into()),

332

1

                crate::SessionKeys {

333

1

                    nimbus: dave_id.clone(),

334

1

},

335

1

                vec![]

336

));

337

338

            // Change invulnerables

339

1

            assert_ok!(Invulnerables::remove_invulnerable(

340

1

                root_origin(),

341

1

                ALICE.into()

342

));

343

1

            assert_ok!(Invulnerables::remove_invulnerable(

344

1

                root_origin(),

345

1

                BOB.into()

346

));

347

1

            assert_ok!(Invulnerables::add_invulnerable(

348

1

                root_origin(),

349

1

                CHARLIE.into()

350

));

351

1

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

352

353

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

354

1

            run_to_session(1u32);

355

1

            let author = get_orchestrator_current_author().unwrap();

356

357

1

            assert_eq!(current_author(), author);

358

1

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

359

360

            // Invulnerables should have triggered on new session authorities change

361

1

            run_to_session(2u32);

362

1

            let author_after_changes = get_orchestrator_current_author().unwrap();

363

364

1

            assert_eq!(current_author(), author_after_changes);

365

1

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

366

1

});

367

1

368

369

#[test]

370

1

fn test_author_collation_aura_add_assigned_to_paras() {

371

1

    ExtBuilder::default()

372

1

        .with_balances(vec![

373

1

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

374

1

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

375

1

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

376

1

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

377

1

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

378

1

])

379

1

        .with_empty_parachains(vec![1001, 1002])

380

1

        .build()

381

1

        .execute_with(|| {

382

1

            run_to_block(2);

383

            // Assert current slot gets updated

384

1

            assert_eq!(current_slot(), 1u64);

385

1

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

386

387

            // We change invulnerables

388

            // We first need to set the keys

389

1

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

390

1

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

391

392

1

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

393

1

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

394

395

            // Set CHARLIE and DAVE keys

396

1

            assert_ok!(Session::set_keys(

397

1

                origin_of(CHARLIE.into()),

398

1

                crate::SessionKeys { nimbus: charlie_id },

399

1

                vec![]

400

));

401

1

            assert_ok!(Session::set_keys(

402

1

                origin_of(DAVE.into()),

403

1

                crate::SessionKeys { nimbus: dave_id },

404

1

                vec![]

405

));

406

407

            // Add new invulnerables

408

1

            assert_ok!(Invulnerables::add_invulnerable(

409

1

                root_origin(),

410

1

                CHARLIE.into()

411

));

412

1

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

413

414

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

415

1

            run_to_session(1u32);

416

1

            let author = get_orchestrator_current_author().unwrap();

417

418

1

            assert_eq!(current_author(), author);

419

1

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

420

421

            // Invulnerables should have triggered on new session authorities change

422

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

423

1

            run_to_session(2u32);

424

1

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

425

1

            let assignment = CollatorAssignment::collator_container_chain();

426

1

            assert_eq!(

427

1

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

428

1

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

429

);

430

1

});

431

1

432

433

#[test]

434

1

fn test_authors_without_paras() {

435

1

    ExtBuilder::default()

436

1

        .with_balances(vec![

437

1

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

438

1

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

439

1

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

440

1

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

441

1

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

442

1

])

443

1

        .with_collators(vec![

444

1

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

445

1

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

446

1

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

447

1

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

448

1

])

449

1

        .build()

450

1

        .execute_with(|| {

451

1

            run_to_block(2);

452

            // Assert current slot gets updated

453

1

            assert_eq!(current_slot(), 1u64);

454

1

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

455

456

            // Only Alice and Bob collate for our chain

457

1

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

458

1

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

459

1

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

460

1

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

461

462

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

463

1

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

464

465

            // Set moondance collators to min 2 max 5

466

1

            assert_ok!(

467

1

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

468

()

469

);

470

1

            assert_ok!(

471

1

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

472

()

473

);

474

475

1

            run_to_session(2);

476

1

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

477

1

});

478

1

479

480

#[test]

481

1

fn test_authors_paras_inserted_a_posteriori() {

482

1

    ExtBuilder::default()

483

1

        .with_balances(vec![

484

1

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

485

1

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

486

1

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

487

1

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

488

1

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

489

1

])

490

1

        .with_collators(vec![

491

1

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

492

1

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

493

1

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

494

1

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

495

1

])

496

1

        .build()

497

1

        .execute_with(|| {

498

1

            run_to_block(2);

499

            // Assert current slot gets updated

500

1

            assert_eq!(current_slot(), 1u64);

501

1

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

502

503

            // Alice and Bob collate in our chain

504

1

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

505

1

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

506

507

1

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

508

509

1

            assert_ok!(Registrar::register(

510

1

                origin_of(ALICE.into()),

511

1

                1001.into(),

512

1

                empty_genesis_data(),

513

1

                None

514

));

515

1

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

516

1

            assert_ok!(Registrar::mark_valid_for_collating(

517

1

                root_origin(),

518

1

                1001.into()

519

));

520

1

            assert_ok!(ServicesPayment::purchase_credits(

521

1

                origin_of(ALICE.into()),

522

1

                1001.into(),

523

1

                block_credits_to_required_balance(1000, 1001.into())

524

));

525

1

            assert_ok!(Registrar::register(

526

1

                origin_of(ALICE.into()),

527

1

                1002.into(),

528

1

                empty_genesis_data(),

529

1

                None

530

));

531

1

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

532

1

            assert_ok!(Registrar::mark_valid_for_collating(

533

1

                root_origin(),

534

1

                1002.into()

535

));

536

1

            assert_ok!(ServicesPayment::purchase_credits(

537

1

                origin_of(ALICE.into()),

538

1

                1002.into(),

539

1

                block_credits_to_required_balance(1000, 1002.into())

540

));

541

542

            // Assignment should happen after 2 sessions

543

1

            run_to_session(1u32);

544

1

            let assignment = CollatorAssignment::collator_container_chain();

545

1

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

546

1

            run_to_session(2u32);

547

548

            // Charlie and Dave should be assigned to para 1001

549

1

            let assignment = CollatorAssignment::collator_container_chain();

550

1

            assert_eq!(

551

1

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

552

1

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

553

);

554

1

});

555

1

556

557

#[test]

558

1

fn test_authors_paras_inserted_a_posteriori_with_collators_already_assigned() {

559

1

    ExtBuilder::default()

560

1

        .with_balances(vec![

561

1

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

562

1

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

563

1

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

564

1

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

565

1

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

566

1

])

567

1

        .with_collators(vec![

568

1

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

569

1

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

570

1

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

571

1

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

572

1

])

573

1

        .with_config(pallet_configuration::HostConfiguration {

574

1

            max_collators: 100,

575

1

            min_orchestrator_collators: 2,

576

1

            max_orchestrator_collators: 5,

577

1

            collators_per_container: 2,

578

1

            full_rotation_period: 0,

579

1

            ..Default::default()

580

1

})

581

1

        .build()

582

1

        .execute_with(|| {

583

1

            run_to_block(2);

584

            // Assert current slot gets updated

585

1

            assert_eq!(current_slot(), 1u64);

586

1

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

587

588

            // Alice and Bob collate in our chain

589

1

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

590

1

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

591

1

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

592

1

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

593

594

1

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

595

596

1

            assert_ok!(Registrar::register(

597

1

                origin_of(ALICE.into()),

598

1

                1001.into(),

599

1

                empty_genesis_data(),

600

1

                None

601

));

602

1

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

603

1

            assert_ok!(Registrar::mark_valid_for_collating(

604

1

                root_origin(),

605

1

                1001.into()

606

));

607

1

            assert_ok!(ServicesPayment::purchase_credits(

608

1

                origin_of(ALICE.into()),

609

1

                1001.into(),

610

1

                block_credits_to_required_balance(1000, 1001.into())

611

));

612

613

            // Assignment should happen after 2 sessions

614

1

            run_to_session(1u32);

615

1

            let assignment = CollatorAssignment::collator_container_chain();

616

1

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

617

1

            run_to_session(2u32);

618

619

            // Charlie and Dave are now assigned to para 1001

620

1

            let assignment = CollatorAssignment::collator_container_chain();

621

1

            assert_eq!(

622

1

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

623

1

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

624

);

625

1

            assert_eq!(

626

                assignment.orchestrator_chain,

627

1

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

628

);

629

1

});

630

1

631

632

#[test]

633

1

fn test_paras_registered_but_zero_credits() {

634

1

    ExtBuilder::default()

635

1

        .with_balances(vec![

636

1

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

637

1

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

638

1

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

639

1

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

640

1

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

641

1

])

642

1

        .with_collators(vec![

643

1

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

644

1

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

645

1

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

646

1

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

647

1

])

648

1

        .build()

649

1

        .execute_with(|| {

650

1

            run_to_block(2);

651

            // Assert current slot gets updated

652

1

            assert_eq!(current_slot(), 1u64);

653

1

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

654

655

            // Alice and Bob collate in our chain

656

1

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

657

1

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

658

659

1

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

660

661

1

            assert_ok!(Registrar::register(

662

1

                origin_of(ALICE.into()),

663

1

                1001.into(),

664

1

                empty_genesis_data(),

665

1

                None

666

));

667

1

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

668

1

            assert_ok!(Registrar::mark_valid_for_collating(

669

1

                root_origin(),

670

1

                1001.into()

671

));

672

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

673

1

            assert_ok!(ServicesPayment::set_block_production_credits(

674

1

                root_origin(),

675

1

                1001.into(),

676

677

));

678

679

            // Assignment should happen after 2 sessions

680

1

            run_to_session(1u32);

681

1

            let assignment = CollatorAssignment::collator_container_chain();

682

1

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

683

1

            run_to_session(2u32);

684

685

            // Nobody should be assigned to para 1001

686

1

            let assignment = CollatorAssignment::collator_container_chain();

687

1

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

688

1

});

689

1

690

691

#[test]

692

1

fn test_paras_registered_but_not_enough_credits() {

693

1

    ExtBuilder::default()

694

1

        .with_balances(vec![

695

1

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

696

1

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

697

1

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

698

1

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

699

1

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

700

1

])

701

1

        .with_collators(vec![

702

1

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

703

1

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

704

1

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

705

1

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

706

1

])

707

1

        .build()

708

1

        .execute_with(|| {

709

1

            run_to_block(2);

710

            // Assert current slot gets updated

711

1

            assert_eq!(current_slot(), 1u64);

712

1

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

713

714

            // Alice and Bob collate in our chain

715

1

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

716

1

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

717

718

1

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

719

720

1

            assert_ok!(Registrar::register(

721

1

                origin_of(ALICE.into()),

722

1

                1001.into(),

723

1

                empty_genesis_data(),

724

1

                None

725

));

726

1

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

727

1

            assert_ok!(Registrar::mark_valid_for_collating(

728

1

                root_origin(),

729

1

                1001.into()

730

));

731

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

732

1

            assert_ok!(ServicesPayment::set_block_production_credits(

733

1

                root_origin(),

734

1

                1001.into(),

735

736

));

737

            // Purchase 1 credit less that what is needed

738

1

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

739

1

            assert_ok!(ServicesPayment::set_block_production_credits(

740

1

                root_origin(),

741

1

                1001.into(),

742

1

                credits_1001

743

));

744

745

            // Assignment should happen after 2 sessions

746

1

            run_to_session(1u32);

747

1

            let assignment = CollatorAssignment::collator_container_chain();

748

1

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

749

1

            run_to_session(2u32);

750

            // Nobody should be assigned to para 1001

751

1

            let assignment = CollatorAssignment::collator_container_chain();

752

1

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

753

754

            // Now purchase the missing block credit

755

1

            assert_ok!(ServicesPayment::set_block_production_credits(

756

1

                root_origin(),

757

1

                1001.into(),

758

1

                credits_1001 + 1

759

));

760

761

1

            run_to_session(4u32);

762

            // Charlie and Dave should be assigned to para 1001

763

1

            let assignment = CollatorAssignment::collator_container_chain();

764

1

            assert_eq!(

765

1

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

766

1

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

767

);

768

1

});

769

1

770

771

#[test]

772

1

fn test_paras_registered_but_only_credits_for_1_session() {

773

1

    ExtBuilder::default()

774

1

        .with_balances(vec![

775

1

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

776

1

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

777

1

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

778

1

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

779

1

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

780

1

])

781

1

        .with_collators(vec![

782

1

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

783

1

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

784

1

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

785

1

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

786

1

])

787

1

        .build()

788

1

        .execute_with(|| {

789

1

            run_to_block(2);

790

            // Assert current slot gets updated

791

1

            assert_eq!(current_slot(), 1u64);

792

1

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

793

794

            // Alice and Bob collate in our chain

795

1

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

796

1

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

797

798

1

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

799

800

1

            assert_ok!(Registrar::register(

801

1

                origin_of(ALICE.into()),

802

1

                1001.into(),

803

1

                empty_genesis_data(),

804

1

                None

805

));

806

1

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

807

1

            assert_ok!(Registrar::mark_valid_for_collating(

808

1

                root_origin(),

809

1

                1001.into()

810

));

811

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

812

1

            assert_ok!(ServicesPayment::set_block_production_credits(

813

1

                root_origin(),

814

1

                1001.into(),

815

816

));

817

            // Purchase only enough credits for 1 session

818

1

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

819

1

            assert_ok!(ServicesPayment::set_block_production_credits(

820

1

                root_origin(),

821

1

                1001.into(),

822

1

                credits_1001

823

));

824

825

            // Assignment should happen after 2 sessions

826

1

            run_to_session(1u32);

827

1

            let assignment = CollatorAssignment::collator_container_chain();

828

1

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

829

1

            run_to_session(2u32);

830

            // Charlie and Dave should be assigned to para 1001

831

1

            let assignment = CollatorAssignment::collator_container_chain();

832

1

            assert_eq!(

833

1

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

834

1

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

835

);

836

837

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

838

1

            run_block();

839

1

            let credits =

840

1

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

841

1

                    .unwrap_or_default();

842

1

            assert_eq!(credits, credits_1001);

843

844

            // Simulate block inclusion from container chain 1001

845

1

            let mut sproof = ParaHeaderSproofBuilder::default();

846

1

            let slot: u64 = 5;

847

1

            let s = ParaHeaderSproofBuilderItem {

848

1

                para_id: 1001.into(),

849

1

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

850

1

                    parent_hash: Default::default(),

851

1

                    number: 1,

852

1

                    state_root: Default::default(),

853

1

                    extrinsics_root: Default::default(),

854

1

                    digest: sp_runtime::generic::Digest {

855

1

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

856

1

},

857

1

}),

858

1

};

859

1

            sproof.items.push(s);

860

1

            set_author_noting_inherent_data(sproof);

861

862

1

            run_block();

863

1

            let credits =

864

1

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

865

1

                    .unwrap_or_default();

866

1

            assert_eq!(credits, credits_1001 - 1);

867

868

1

            run_to_session(4u32);

869

            // Nobody should be assigned to para 1001

870

1

            let assignment = CollatorAssignment::collator_container_chain();

871

1

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

872

873

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

874

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

875

1

            let credits =

876

1

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

877

1

                    .unwrap_or_default();

878

1

            assert_eq!(credits, credits_1001 - 1);

879

1

});

880

1

881

882

#[test]

883

1

fn test_parachains_deregister_collators_re_assigned() {

884

1

    ExtBuilder::default()

885

1

        .with_balances(vec![

886

1

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

887

1

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

888

1

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

889

1

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

890

1

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

891

1

])

892

1

        .with_collators(vec![

893

1

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

894

1

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

895

1

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

896

1

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

897

1

])

898

1

        .with_empty_parachains(vec![1001, 1002])

899

1

        .build()

900

1

        .execute_with(|| {

901

1

            run_to_block(2);

902

            // Assert current slot gets updated

903

1

            assert_eq!(current_slot(), 1u64);

904

1

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

905

906

            // Alice and Bob are authorities

907

1

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

908

1

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

909

910

1

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

911

912

            // Charlie and Dave to 1001

913

1

            let assignment = CollatorAssignment::collator_container_chain();

914

1

            assert_eq!(

915

1

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

916

1

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

917

);

918

919

1

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

920

921

            // Assignment should happen after 2 sessions

922

1

            run_to_session(1u32);

923

924

1

            let assignment = CollatorAssignment::collator_container_chain();

925

1

            assert_eq!(

926

1

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

927

1

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

928

);

929

930

1

            run_to_session(2u32);

931

932

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

933

1

            let assignment = CollatorAssignment::collator_container_chain();

934

1

            assert_eq!(

935

1

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

936

1

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

937

);

938

1

});

939

1

940

941

#[test]

942

1

fn test_parachains_deregister_collators_config_change_reassigned() {

943

1

    ExtBuilder::default()

944

1

        .with_balances(vec![

945

1

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

946

1

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

947

1

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

948

1

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

949

1

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

950

1

])

951

1

        .with_collators(vec![

952

1

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

953

1

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

954

1

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

955

1

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

956

1

])

957

1

        .with_empty_parachains(vec![1001, 1002])

958

1

        .build()

959

1

        .execute_with(|| {

960

1

            run_to_block(2);

961

            // Assert current slot gets updated

962

1

            assert_eq!(current_slot(), 1u64);

963

1

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

964

965

            // Alice and Bob are authorities

966

1

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

967

1

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

968

969

1

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

970

971

            // Set orchestrator collators to 1

972

1

            assert_ok!(

973

1

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

974

()

975

);

976

977

            // Set container chain collators to 3

978

1

            assert_ok!(

979

1

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

980

()

981

);

982

983

            // Charlie and Dave to 1001

984

1

            let assignment = CollatorAssignment::collator_container_chain();

985

1

            assert_eq!(

986

1

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

987

1

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

988

);

989

990

            // Assignment should happen after 2 sessions

991

1

            run_to_session(1u32);

992

993

1

            let assignment = CollatorAssignment::collator_container_chain();

994

1

            assert_eq!(

995

1

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

996

1

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

997

);

998

999

1

            run_to_session(2u32);

1000

1001

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

1002

1

            let assignment = CollatorAssignment::collator_container_chain();

1003

1

            assert_eq!(

1004

1

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

1005

1

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

1006

);

1007

1008

1

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

1009

1

});

1010

1

1011

1012

#[test]

1013

1

fn test_orchestrator_collators_with_non_sufficient_collators() {

1014

1

    ExtBuilder::default()

1015

1

        .with_balances(vec![

1016

1

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

1017

1

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

1018

1

])

1019

1

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

1020

1

        .with_empty_parachains(vec![1001, 1002])

1021

1

        .build()

1022

1

        .execute_with(|| {

1023

1

            run_to_block(2);

1024

            // Assert current slot gets updated

1025

1

            assert_eq!(current_slot(), 1u64);

1026

1

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

1027

1028

            // Alice and Bob are authorities

1029

1

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

1030

1031

1

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

1032

1

});

1033

1

1034

1035

#[test]

1036

1

fn test_configuration_on_session_change() {

1037

1

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

1038

1

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

1039

1

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

1040

1

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

1041

1042

1

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

1043

1

        run_to_session(1u32);

1044

1045

1

        assert_ok!(

1046

1

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

1047

()

1048

);

1049

1

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

1050

1

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

1051

1

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

1052

1053

1

        run_to_session(2u32);

1054

1

        assert_ok!(

1055

1

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

1056

()

1057

);

1058

1

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

1059

1

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

1060

1

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

1061

1062

1

        run_to_session(3u32);

1063

1064

1

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

1065

1

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

1066

1

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

1067

1068

1

        run_to_session(4u32);

1069

1070

1

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

1071

1

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

1072

1

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

1073

1

});

1074

1

1075

1076

#[test]

1077

1

fn test_author_collation_aura_add_assigned_to_paras_runtime_api() {

1078

1

    ExtBuilder::default()

1079

1

        .with_balances(vec![

1080

1

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

1081

1

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

1082

1

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

1083

1

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

1084

1

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

1085

1

])

1086

1

        .with_empty_parachains(vec![1001, 1002])

1087

1

        .build()

1088

1

        .execute_with(|| {

1089

1

            run_to_block(2);

1090

            // Assert current slot gets updated

1091

1

            assert_eq!(current_slot(), 1u64);

1092

1

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

1093

1

            assert_eq!(

1094

1

                parachain_collators(100.into()),

1095

1

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

1096

);

1097

1

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

1098

1

            assert_eq!(

1099

1

                current_collator_parachain_assignment(ALICE.into()),

1100

1

                Some(100.into())

1101

);

1102

1

            assert_eq!(

1103

1

                future_collator_parachain_assignment(ALICE.into()),

1104

1

                Some(100.into())

1105

);

1106

1

            assert_eq!(current_collator_parachain_assignment(CHARLIE.into()), None);

1107

1

            assert_eq!(future_collator_parachain_assignment(CHARLIE.into()), None);

1108

1109

            // We change invulnerables

1110

            // We first need to set the keys

1111

1

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

1112

1

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

1113

1114

1

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

1115

1

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

1116

1117

            // Set CHARLIE and DAVE keys

1118

1

            assert_ok!(Session::set_keys(

1119

1

                origin_of(CHARLIE.into()),

1120

1

                crate::SessionKeys { nimbus: charlie_id },

1121

1

                vec![]

1122

));

1123

1

            assert_ok!(Session::set_keys(

1124

1

                origin_of(DAVE.into()),

1125

1

                crate::SessionKeys { nimbus: dave_id },

1126

1

                vec![]

1127

));

1128

1129

            // Set new invulnerables

1130

1

            assert_ok!(Invulnerables::add_invulnerable(

1131

1

                root_origin(),

1132

1

                CHARLIE.into()

1133

));

1134

1

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

1135

1136

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

1137

1

            run_to_session(1u32);

1138

1

            let author = get_orchestrator_current_author().unwrap();

1139

1140

1

            assert_eq!(current_author(), author);

1141

1

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

1142

1

            assert_eq!(

1143

1

                parachain_collators(100.into()),

1144

1

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

1145

);

1146

1

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

1147

1

            assert_eq!(current_collator_parachain_assignment(CHARLIE.into()), None);

1148

1

            assert_eq!(

1149

1

                future_collator_parachain_assignment(CHARLIE.into()),

1150

1

                Some(1001.into())

1151

);

1152

1153

            // Invulnerables should have triggered on new session authorities change

1154

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

1155

1

            run_to_session(2u32);

1156

1

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

1157

1

            let assignment = CollatorAssignment::collator_container_chain();

1158

1

            assert_eq!(

1159

1

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

1160

1

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

1161

);

1162

1163

1

            assert_eq!(

1164

1

                parachain_collators(100.into()),

1165

1

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

1166

);

1167

1

            assert_eq!(

1168

1

                parachain_collators(1001.into()),

1169

1

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

1170

);

1171

1

            assert_eq!(

1172

1

                current_collator_parachain_assignment(CHARLIE.into()),

1173

1

                Some(1001.into())

1174

);

1175

1

            assert_eq!(

1176

1

                future_collator_parachain_assignment(CHARLIE.into()),

1177

1

                Some(1001.into())

1178

);

1179

1180

            // Remove BOB

1181

1

            assert_ok!(Invulnerables::remove_invulnerable(

1182

1

                root_origin(),

1183

1

                BOB.into()

1184

));

1185

1186

1

            run_to_session(3u32);

1187

1

            assert_eq!(

1188

1

                parachain_collators(100.into()),

1189

1

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

1190

);

1191

1

            assert_eq!(

1192

1

                parachain_collators(1001.into()),

1193

1

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

1194

);

1195

1

            assert_eq!(

1196

1

                current_collator_parachain_assignment(BOB.into()),

1197

1

                Some(100.into())

1198

);

1199

1

            assert_eq!(future_collator_parachain_assignment(BOB.into()), None);

1200

1201

1

            run_to_session(4u32);

1202

1

            assert_eq!(

1203

1

                parachain_collators(100.into()),

1204

1

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

1205

);

1206

1

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

1207

1

            assert_eq!(current_collator_parachain_assignment(BOB.into()), None);

1208

1

            assert_eq!(future_collator_parachain_assignment(BOB.into()), None);

1209

1

});

1210

1

1211

1212

#[test]

1213

1

fn test_consensus_runtime_api() {

1214

1

    ExtBuilder::default()

1215

1

        .with_balances(vec![

1216

1

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

1217

1

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

1218

1

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

1219

1

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

1220

1

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

1221

1

])

1222

1

        .with_empty_parachains(vec![1001, 1002])

1223

1

        .build()

1224

1

        .execute_with(|| {

1225

1

            run_to_block(2);

1226

1227

1

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

1228

1

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

1229

1230

1

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

1231

1

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

1232

1233

1

            assert_eq!(

1234

1

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

1235

1

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

1236

);

1237

1

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

1238

1

            assert_eq!(

1239

1

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

1240

1

                Some(100.into())

1241

);

1242

1

            assert_eq!(

1243

1

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

1244

1

                Some(100.into())

1245

);

1246

1

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

1247

1

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

1248

1249

            // Set CHARLIE and DAVE keys

1250

1

            assert_ok!(Session::set_keys(

1251

1

                origin_of(CHARLIE.into()),

1252

1

                crate::SessionKeys {

1253

1

                    nimbus: charlie_id.clone(),

1254

1

},

1255

1

                vec![]

1256

));

1257

1

            assert_ok!(Session::set_keys(

1258

1

                origin_of(DAVE.into()),

1259

1

                crate::SessionKeys {

1260

1

                    nimbus: dave_id.clone(),

1261

1

},

1262

1

                vec![]

1263

));

1264

1265

            // Set new invulnerables

1266

1

            assert_ok!(Invulnerables::add_invulnerable(

1267

1

                root_origin(),

1268

1

                CHARLIE.into()

1269

));

1270

1

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

1271

1272

1

            run_to_session(2u32);

1273

1

            assert_eq!(

1274

1

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

1275

1

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

1276

);

1277

1

            assert_eq!(

1278

1

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

1279

1

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

1280

);

1281

1

            assert_eq!(

1282

1

                Runtime::check_para_id_assignment(alice_id),

1283

1

                Some(100.into())

1284

);

1285

1

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

1286

1

            assert_eq!(

1287

1

                Runtime::check_para_id_assignment(charlie_id),

1288

1

                Some(1001.into())

1289

);

1290

1

            assert_eq!(

1291

1

                Runtime::check_para_id_assignment(dave_id),

1292

1

                Some(1001.into())

1293

);

1294

1

});

1295

1

1296

1297

#[test]

1298

1

fn test_consensus_runtime_api_session_changes() {

1299

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

1300

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

1301

    // if we can predict correctly

1302

1

    ExtBuilder::default()

1303

1

        .with_balances(vec![

1304

1

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

1305

1

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

1306

1

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

1307

1

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

1308

1

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

1309

1

])

1310

1

        .with_empty_parachains(vec![1001, 1002])

1311

1

        .build()

1312

1

        .execute_with(|| {

1313

1

            run_to_block(2);

1314

1315

1

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

1316

1

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

1317

1318

1

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

1319

1

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

1320

1321

1

            assert_eq!(

1322

1

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

1323

1

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

1324

);

1325

1

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

1326

1

            assert_eq!(

1327

1

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

1328

1

                Some(100.into())

1329

);

1330

1

            assert_eq!(

1331

1

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

1332

1

                Some(100.into())

1333

);

1334

1

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

1335

1

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

1336

1337

            // Set CHARLIE and DAVE keys

1338

1

            assert_ok!(Session::set_keys(

1339

1

                origin_of(CHARLIE.into()),

1340

1

                crate::SessionKeys {

1341

1

                    nimbus: charlie_id.clone(),

1342

1

},

1343

1

                vec![]

1344

));

1345

1

            assert_ok!(Session::set_keys(

1346

1

                origin_of(DAVE.into()),

1347

1

                crate::SessionKeys {

1348

1

                    nimbus: dave_id.clone(),

1349

1

},

1350

1

                vec![]

1351

));

1352

1353

            // Set new invulnerables

1354

1

            assert_ok!(Invulnerables::add_invulnerable(

1355

1

                root_origin(),

1356

1

                CHARLIE.into()

1357

));

1358

1

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

1359

1360

1

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

1361

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

1362

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

1363

            // edge of a session change

1364

1

            run_to_block(session_two_edge - 2);

1365

1366

1

            assert_eq!(

1367

1

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

1368

1

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

1369

);

1370

1

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

1371

1

            assert_eq!(

1372

1

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

1373

1

                Some(100.into())

1374

);

1375

1

            assert_eq!(

1376

1

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

1377

1

                Some(100.into())

1378

);

1379

1

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

1380

1

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

1381

1382

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

1383

            // authorities of the next block!

1384

1

            run_to_block(session_two_edge - 1);

1385

1

            assert_eq!(

1386

1

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

1387

1

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

1388

);

1389

1

            assert_eq!(

1390

1

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

1391

1

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

1392

);

1393

1

            assert_eq!(

1394

1

                Runtime::check_para_id_assignment(alice_id),

1395

1

                Some(100.into())

1396

);

1397

1

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

1398

1

            assert_eq!(

1399

1

                Runtime::check_para_id_assignment(charlie_id),

1400

1

                Some(1001.into())

1401

);

1402

1

            assert_eq!(

1403

1

                Runtime::check_para_id_assignment(dave_id),

1404

1

                Some(1001.into())

1405

);

1406

1

});

1407

1

1408

1409

#[test]

1410

1

fn test_consensus_runtime_api_next_session() {

1411

1

    ExtBuilder::default()

1412

1

        .with_balances(vec![

1413

1

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

1414

1

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

1415

1

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

1416

1

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

1417

1

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

1418

1

])

1419

1

        .with_empty_parachains(vec![1001, 1002])

1420

1

        .build()

1421

1

        .execute_with(|| {

1422

1

            run_to_block(2);

1423

1424

1

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

1425

1

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

1426

1427

1

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

1428

1

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

1429

1430

1

            assert_eq!(

1431

1

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

1432

1

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

1433

);

1434

1

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

1435

1

            assert_eq!(

1436

1

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

1437

1

                Some(100.into())

1438

);

1439

1

            assert_eq!(

1440

1

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

1441

1

                Some(100.into())

1442

);

1443

1

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

1444

1

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

1445

1446

            // In the next session the assignment will not change

1447

1

            assert_eq!(

1448

1

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

1449

1

                Some(100.into())

1450

);

1451

1

            assert_eq!(

1452

1

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

1453

1

                Some(100.into())

1454

);

1455

1

            assert_eq!(

1456

1

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

1457

                None,

1458

);

1459

1

            assert_eq!(

1460

1

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

1461

                None,

1462

);

1463

1464

            // Set CHARLIE and DAVE keys

1465

1

            assert_ok!(Session::set_keys(

1466

1

                origin_of(CHARLIE.into()),

1467

1

                crate::SessionKeys {

1468

1

                    nimbus: charlie_id.clone(),

1469

1

},

1470

1

                vec![]

1471

));

1472

1

            assert_ok!(Session::set_keys(

1473

1

                origin_of(DAVE.into()),

1474

1

                crate::SessionKeys {

1475

1

                    nimbus: dave_id.clone(),

1476

1

},

1477

1

                vec![]

1478

));

1479

1480

            // Set new invulnerables

1481

1

            assert_ok!(Invulnerables::add_invulnerable(

1482

1

                root_origin(),

1483

1

                CHARLIE.into()

1484

));

1485

1

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

1486

1487

1

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

1488

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

1489

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

1490

            // edge of a session change

1491

1

            run_to_block(session_two_edge - 2);

1492

1493

1

            assert_eq!(

1494

1

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

1495

1

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

1496

);

1497

1

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

1498

1

            assert_eq!(

1499

1

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

1500

1

                Some(100.into())

1501

);

1502

1

            assert_eq!(

1503

1

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

1504

1

                Some(100.into())

1505

);

1506

1

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

1507

1

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

1508

1509

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

1510

1

            assert_eq!(

1511

1

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

1512

1

                Some(100.into())

1513

);

1514

1

            assert_eq!(

1515

1

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

1516

1

                Some(100.into())

1517

);

1518

1

            assert_eq!(

1519

1

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

1520

1

                Some(1001.into()),

1521

);

1522

1

            assert_eq!(

1523

1

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

1524

1

                Some(1001.into()),

1525

);

1526

1527

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

1528

            // authorities of the next block!

1529

1

            run_to_block(session_two_edge - 1);

1530

1

            assert_eq!(

1531

1

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

1532

1

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

1533

);

1534

1

            assert_eq!(

1535

1

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

1536

1

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

1537

);

1538

1

            assert_eq!(

1539

1

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

1540

1

                Some(100.into())

1541

);

1542

1

            assert_eq!(

1543

1

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

1544

1

                Some(100.into())

1545

);

1546

1

            assert_eq!(

1547

1

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

1548

1

                Some(1001.into())

1549

);

1550

1

            assert_eq!(

1551

1

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

1552

1

                Some(1001.into())

1553

);

1554

1555

            // check_para_id_assignment_next_session returns the same value as check_para_id_assignment

1556

            // because we are on a session boundary

1557

1

            assert_eq!(

1558

1

                Runtime::check_para_id_assignment_next_session(alice_id),

1559

1

                Some(100.into())

1560

);

1561

1

            assert_eq!(

1562

1

                Runtime::check_para_id_assignment_next_session(bob_id),

1563

1

                Some(100.into())

1564

);

1565

1

            assert_eq!(

1566

1

                Runtime::check_para_id_assignment_next_session(charlie_id),

1567

1

                Some(1001.into())

1568

);

1569

1

            assert_eq!(

1570

1

                Runtime::check_para_id_assignment_next_session(dave_id),

1571

1

                Some(1001.into())

1572

);

1573

1

});

1574

1

1575

1576

#[test]

1577

1

fn test_author_noting_self_para_id_not_noting() {

1578

1

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

1579

1

        let mut sproof = ParaHeaderSproofBuilder::default();

1580

1

        let slot: u64 = 5;

1581

1

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

1582

1

        let s = ParaHeaderSproofBuilderItem {

1583

1

            para_id: self_para,

1584

1

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

1585

1

                parent_hash: Default::default(),

1586

1

                number: Default::default(),

1587

1

                state_root: Default::default(),

1588

1

                extrinsics_root: Default::default(),

1589

1

                digest: sp_runtime::generic::Digest {

1590

1

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

1591

1

},

1592

1

}),

1593

1

};

1594

1

        sproof.items.push(s);

1595

1596

1

        set_author_noting_inherent_data(sproof);

1597

1598

1

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

1599

1

});

1600

1

1601

1602

#[test]

1603

1

fn test_author_noting_not_self_para() {

1604

1

    ExtBuilder::default()

1605

1

        .with_balances(vec![

1606

1

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

1607

1

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

1608

1

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

1609

1

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

1610

1

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

1611

1

])

1612

1

        .with_collators(vec![

1613

1

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

1614

1

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

1615

1

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

1616

1

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

1617

1

])

1618

1

        .with_empty_parachains(vec![1001, 1002])

1619

1

        .build()

1620

1

        .execute_with(|| {

1621

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1622

1

            let slot: u64 = 5;

1623

1

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

1624

1625

            // Charlie and Dave to 1001

1626

1

            let assignment = CollatorAssignment::collator_container_chain();

1627

1

            assert_eq!(

1628

1

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

1629

1

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

1630

);

1631

1632

1

            let s = ParaHeaderSproofBuilderItem {

1633

1

                para_id: other_para,

1634

1

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

1635

1

                    parent_hash: Default::default(),

1636

1

                    number: 1,

1637

1

                    state_root: Default::default(),

1638

1

                    extrinsics_root: Default::default(),

1639

1

                    digest: sp_runtime::generic::Digest {

1640

1

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

1641

1

},

1642

1

}),

1643

1

};

1644

1

            sproof.items.push(s);

1645

1646

1

            set_author_noting_inherent_data(sproof);

1647

1648

1

            assert_eq!(

1649

1

                AuthorNoting::latest_author(other_para),

1650

1

                Some(ContainerChainBlockInfo {

1651

1

                    block_number: 1,

1652

1

                    author: AccountId::from(DAVE),

1653

1

                    latest_slot_number: 0.into(),

1654

1

})

1655

);

1656

1

});

1657

1

1658

1659

#[test]

1660

1

fn test_author_noting_set_author_and_kill_author_data() {

1661

1

    ExtBuilder::default()

1662

1

        .with_balances(vec![

1663

1

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

1664

1

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

1665

1

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

1666

1

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

1667

1

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

1668

1

])

1669

1

        .with_collators(vec![

1670

1

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

1671

1

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

1672

1

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

1673

1

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

1674

1

])

1675

1

        .with_empty_parachains(vec![1001, 1002])

1676

1

        .build()

1677

1

        .execute_with(|| {

1678

1

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

1679

1680

1

            assert_ok!(AuthorNoting::set_author(

1681

1

                root_origin(),

1682

1

                other_para,

1683

1,

1684

1

                AccountId::from(DAVE),

1685

1

                1.into()

1686

));

1687

1688

1

            assert_eq!(

1689

1

                AuthorNoting::latest_author(other_para),

1690

1

                Some(ContainerChainBlockInfo {

1691

1

                    block_number: 1,

1692

1

                    author: AccountId::from(DAVE),

1693

1

                    latest_slot_number: 1.into(),

1694

1

})

1695

);

1696

1697

1

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

1698

1699

1

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

1700

1

});

1701

1

1702

1703

#[test]

1704

1

fn test_author_noting_set_author_and_kill_author_data_bad_origin() {

1705

1

    ExtBuilder::default()

1706

1

        .with_balances(vec![

1707

1

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

1708

1

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

1709

1

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

1710

1

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

1711

1

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

1712

1

])

1713

1

        .with_collators(vec![

1714

1

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

1715

1

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

1716

1

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

1717

1

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

1718

1

])

1719

1

        .with_empty_parachains(vec![1001, 1002])

1720

1

        .build()

1721

1

        .execute_with(|| {

1722

1

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

1723

1724

1

            assert_noop!(

1725

1

                AuthorNoting::set_author(

1726

1

                    origin_of(ALICE.into()),

1727

1

                    other_para,

1728

1,

1729

1

                    AccountId::from(DAVE),

1730

1

                    1.into()

1731

),

1732

1

                BadOrigin

1733

);

1734

1735

1

            assert_noop!(

1736

1

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

1737

1

                BadOrigin

1738

);

1739

1

});

1740

1

1741

1742

#[test]

1743

1

fn test_author_noting_runtime_api() {

1744

1

    ExtBuilder::default()

1745

1

        .with_balances(vec![

1746

1

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

1747

1

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

1748

1

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

1749

1

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

1750

1

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

1751

1

])

1752

1

        .with_collators(vec![

1753

1

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

1754

1

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

1755

1

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

1756

1

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

1757

1

])

1758

1

        .with_empty_parachains(vec![1001, 1002])

1759

1

        .build()

1760

1

        .execute_with(|| {

1761

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1762

1

            let slot: u64 = 5;

1763

1

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

1764

1765

            // Charlie and Dave to 1001

1766

1

            let assignment = CollatorAssignment::collator_container_chain();

1767

1

            assert_eq!(

1768

1

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

1769

1

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

1770

);

1771

1772

1

            let s = ParaHeaderSproofBuilderItem {

1773

1

                para_id: other_para,

1774

1

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

1775

1

                    parent_hash: Default::default(),

1776

1

                    number: 1,

1777

1

                    state_root: Default::default(),

1778

1

                    extrinsics_root: Default::default(),

1779

1

                    digest: sp_runtime::generic::Digest {

1780

1

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

1781

1

},

1782

1

}),

1783

1

};

1784

1

            sproof.items.push(s);

1785

1786

1

            set_author_noting_inherent_data(sproof);

1787

1788

1

            assert_eq!(

1789

1

                AuthorNoting::latest_author(other_para),

1790

1

                Some(ContainerChainBlockInfo {

1791

1

                    block_number: 1,

1792

1

                    author: AccountId::from(DAVE),

1793

1

                    latest_slot_number: 0.into(),

1794

1

})

1795

);

1796

1797

1

            assert_eq!(

1798

1

                Runtime::latest_author(other_para),

1799

1

                Some(AccountId::from(DAVE))

1800

);

1801

1

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

1802

1

});

1803

1

1804

1805

#[test]

1806

1

fn session_keys_key_type_id() {

1807

1

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

1808

1

1809

1810

#[test]

1811

1

fn test_session_keys_with_authority_mapping() {

1812

1

    ExtBuilder::default()

1813

1

        .with_balances(vec![

1814

1

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

1815

1

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

1816

1

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

1817

1

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

1818

1

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

1819

1

])

1820

1

        .with_empty_parachains(vec![1001, 1002])

1821

1

        .build()

1822

1

        .execute_with(|| {

1823

1

            run_to_block(2);

1824

1

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

1825

1

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

1826

1

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

1827

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1828

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1829

1830

1

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

1831

1

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

1832

1

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

1833

1834

            // Everything should match to aura

1835

1

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

1836

1837

            // Change Alice and Bob keys to something different

1838

            // for now lets change it to alice_2 and bob_2

1839

1

            assert_ok!(Session::set_keys(

1840

1

                origin_of(ALICE.into()),

1841

1

                crate::SessionKeys {

1842

1

                    nimbus: alice_id_2.clone(),

1843

1

},

1844

1

                vec![]

1845

));

1846

1

            assert_ok!(Session::set_keys(

1847

1

                origin_of(BOB.into()),

1848

1

                crate::SessionKeys {

1849

1

                    nimbus: bob_id_2.clone(),

1850

1

},

1851

1

                vec![]

1852

));

1853

1854

1

            run_to_session(1u32);

1855

1

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

1856

1

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

1857

1

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

1858

1

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

1859

1860

1

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

1861

1

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

1862

1

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

1863

1

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

1864

1865

            // Everything should match to aura

1866

1

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

1867

//

1868

1869

1

            run_to_session(2u32);

1870

1

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

1871

1872

1

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

1873

1

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

1874

1

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

1875

1

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

1876

1877

1

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

1878

1

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

1879

1

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

1880

1

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

1881

1882

            // Everything should match to aura

1883

1

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

1884

1

});

1885

1

1886

1887

#[test]

1888

1

fn test_session_keys_with_authority_assignment() {

1889

1

    ExtBuilder::default()

1890

1

        .with_balances(vec![

1891

1

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

1892

1

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

1893

1

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

1894

1

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

1895

1

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

1896

1

])

1897

1

        .with_empty_parachains(vec![1001, 1002])

1898

1

        .build()

1899

1

        .execute_with(|| {

1900

1

            run_to_block(2);

1901

1

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

1902

1

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

1903

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1904

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1905

1906

1

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

1907

1

            assert_eq!(

1908

                key_mapping_session_0.orchestrator_chain,

1909

1

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

1910

);

1911

1

            assert_eq!(

1912

1

                CollatorAssignment::collator_container_chain().orchestrator_chain,

1913

1

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

1914

);

1915

1916

1

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

1917

1

            assert_eq!(key_mapping_session_1, key_mapping_session_0,);

1918

1

            let old_assignment_session_1 =

1919

1

                CollatorAssignment::pending_collator_container_chain().unwrap();

1920

1

            assert_eq!(

1921

                old_assignment_session_1,

1922

1

                CollatorAssignment::collator_container_chain(),

1923

);

1924

1925

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2);

1926

1

            assert!(key_mapping_session_2.is_none());

1927

1928

            // Everything should match to aura

1929

1

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

1930

1931

            // Change Alice and Bob keys to something different

1932

            // for now lets change it to alice_2 and bob_2

1933

1

            assert_ok!(Session::set_keys(

1934

1

                origin_of(ALICE.into()),

1935

1

                crate::SessionKeys {

1936

1

                    nimbus: alice_id_2.clone(),

1937

1

},

1938

1

                vec![]

1939

));

1940

1

            assert_ok!(Session::set_keys(

1941

1

                origin_of(BOB.into()),

1942

1

                crate::SessionKeys {

1943

1

                    nimbus: bob_id_2.clone(),

1944

1

},

1945

1

                vec![]

1946

));

1947

1948

1

            run_to_session(1u32);

1949

1

            let old_key_mapping_session_1 = key_mapping_session_1;

1950

1951

            // Session 0 got removed

1952

1

            let key_mapping_session_0 = AuthorityAssignment::collator_container_chain(0);

1953

1

            assert!(key_mapping_session_0.is_none());

1954

1955

            // The values at session 1 did not change

1956

1

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

1957

1

            assert_eq!(key_mapping_session_1, old_key_mapping_session_1,);

1958

1

            assert_eq!(

1959

1

                CollatorAssignment::collator_container_chain(),

1960

                old_assignment_session_1,

1961

);

1962

1963

            // Session 2 uses the new keys

1964

1

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

1965

1

            assert_eq!(

1966

                key_mapping_session_2.orchestrator_chain,

1967

1

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

1968

);

1969

1

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

1970

1971

1

            let key_mapping_session_3 = AuthorityAssignment::collator_container_chain(3);

1972

1

            assert!(key_mapping_session_3.is_none());

1973

1974

            // Everything should match to aura

1975

1

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

1976

1977

1

            run_to_session(2u32);

1978

1979

            // Session 1 got removed

1980

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1);

1981

1

            assert!(key_mapping_session_1.is_none());

1982

1983

            // Session 2 uses the new keys

1984

1

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

1985

1

            assert_eq!(

1986

                key_mapping_session_2.orchestrator_chain,

1987

1

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

1988

);

1989

1

            assert_eq!(

1990

                old_assignment_session_1,

1991

1

                CollatorAssignment::collator_container_chain(),

1992

);

1993

1994

            // Session 3 uses the new keys

1995

1

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

1996

1

            assert_eq!(

1997

                key_mapping_session_3.orchestrator_chain,

1998

1

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

1999

);

2000

1

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

2001

2002

1

            let key_mapping_session_4 = AuthorityAssignment::collator_container_chain(4);

2003

1

            assert!(key_mapping_session_4.is_none());

2004

2005

            // Everything should match to aura

2006

1

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

2007

1

});

2008

1

2009

2010

2

fn call_transfer(

2011

2

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

2012

2

    value: u128,

2013

2

) -> RuntimeCall {

2014

2

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

2015

2

2016

2017

#[test]

2018

1

fn test_proxy_any() {

2019

1

    ExtBuilder::default()

2020

1

        .with_balances(vec![

2021

1

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

2022

1

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

2023

1

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

2024

1

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

2025

1

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

2026

1

])

2027

1

        .build()

2028

1

        .execute_with(|| {

2029

1

            run_to_block(2);

2030

2031

1

            let delay = 0;

2032

1

            assert_ok!(Proxy::add_proxy(

2033

1

                origin_of(ALICE.into()),

2034

1

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

2035

1

                ProxyType::Any,

2036

1

                delay

2037

));

2038

2039

1

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

2040

1

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

2041

1

            assert_ok!(Proxy::proxy(

2042

1

                origin_of(BOB.into()),

2043

1

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

2044

1

                None,

2045

1

                call

2046

));

2047

1

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

2048

2049

1

            assert_eq!(balance_after, balance_before + 200_000);

2050

1

});

2051

1

2052

2053

#[test]

2054

1

fn test_proxy_non_transfer() {

2055

1

    ExtBuilder::default()

2056

1

        .with_balances(vec![

2057

1

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

2058

1

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

2059

1

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

2060

1

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

2061

1

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

2062

1

])

2063

1

        .build()

2064

1

        .execute_with(|| {

2065

1

            run_to_block(2);

2066

2067

1

            let delay = 0;

2068

1

            assert_ok!(Proxy::add_proxy(

2069

1

                origin_of(ALICE.into()),

2070

1

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

2071

1

                ProxyType::NonTransfer,

2072

1

                delay

2073

));

2074

2075

1

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

2076

1

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

2077

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

2078

1

            assert_ok!(Proxy::proxy(

2079

1

                origin_of(BOB.into()),

2080

1

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

2081

1

                None,

2082

1

                call

2083

));

2084

1

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

2085

2086

1

            assert_eq!(balance_after, balance_before);

2087

1

});

2088

1

2089

2090

#[test]

2091

1

fn test_proxy_utility() {

2092

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

2093

    // subcalls don't allow to circumvent filters.

2094

2095

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

2096

1

    match ProxyType::Any {

2097

        ProxyType::Any

2098

        | ProxyType::NonTransfer

2099

        | ProxyType::Governance

2100

        | ProxyType::Staking

2101

        | ProxyType::CancelProxy

2102

        | ProxyType::Balances

2103

        | ProxyType::Registrar

2104

1

        | ProxyType::SudoRegistrar => (),

2105

};

2106

2107

    // All except for any

2108

1

    let proxy_types = &[

2109

1

        ProxyType::NonTransfer,

2110

1

        ProxyType::Governance,

2111

1

        ProxyType::Staking,

2112

1

        ProxyType::CancelProxy,

2113

1

        ProxyType::Balances,

2114

1

        ProxyType::Registrar,

2115

1

        ProxyType::SudoRegistrar,

2116

1

];

2117

2118

8

    for &proxy_type in proxy_types {

2119

7

        ExtBuilder::default()

2120

7

            .with_balances(vec![

2121

7

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

2122

7

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

2123

7

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

2124

7

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

2125

7

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

2126

7

])

2127

7

            .with_sudo(AccountId::from(ALICE))

2128

7

            .build()

2129

7

            .execute_with(|| {

2130

7

                assert_ok!(Proxy::add_proxy(

2131

7

                    origin_of(ALICE.into()),

2132

7

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

2133

7

                    proxy_type,

2134

2135

));

2136

2137

7

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

2138

2139

7

                assert_ok!(Proxy::proxy(

2140

7

                    origin_of(BOB.into()),

2141

7

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

2142

7

                    None,

2143

7

                    Box::new(

2144

7

                        pallet_sudo::Call::sudo {

2145

7

                            call: Box::new(

2146

7

                                pallet_utility::Call::batch {

2147

7

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

2148

7

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

2149

7

                                        new_free: 42424242424242

2150

7

2151

7

                                    .into()]

2152

7

2153

7

                                .into()

2154

7

2155

7

2156

7

                        .into()

2157

2158

));

2159

2160

7

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

2161

7

});

2162

2163

1

2164

2165

#[test]

2166

1

fn check_well_known_keys() {

2167

    use frame_support::traits::PalletInfo;

2168

2169

    // Pallet is named "Paras" in Polkadot.

2170

1

    assert_eq!(

2171

        well_known_keys::PARAS_HEADS_INDEX,

2172

1

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

2173

);

2174

2175

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

2176

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

2177

1

    assert_eq!(

2178

1

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

2179

        Some("AuthorityAssignment")

2180

);

2181

1

    assert_eq!(

2182

        well_known_keys::AUTHORITY_ASSIGNMENT_PREFIX,

2183

1

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

2184

);

2185

2186

1

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

2187

1

    assert_eq!(

2188

        well_known_keys::SESSION_INDEX,

2189

1

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

2190

);

2191

1

2192

2193

#[test]

2194

1

fn test_reward_to_invulnerable() {

2195

    // Alice, Bob, Charlie are invulnerables

2196

1

    ExtBuilder::default()

2197

1

        .with_balances(vec![

2198

1

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

2199

1

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

2200

1

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

2201

1

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

2202

1

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

2203

1

])

2204

1

        .with_collators(vec![

2205

1

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

2206

1

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

2207

1

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

2208

1

])

2209

1

        .with_empty_parachains(vec![1001, 1002])

2210

1

        .build()

2211

1

        .execute_with(|| {

2212

1

            run_to_block(2);

2213

2214

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

2215

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

2216

            // rewards.

2217

2218

            // wait for next session so that ALICE is elected

2219

1

            run_to_session(4u32);

2220

2221

1

            let account: AccountId = ALICE.into();

2222

1

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

2223

2224

1

            let summary = (0..100)

2225

2

                .find_map(|_| {

2226

2

                    let summary = run_block();

2227

2

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

2228

1

                        Some(summary)

2229

                    } else {

2230

1

                        None

2231

2232

2

})

2233

1

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

2234

2235

1

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

2236

2237

1

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

2238

            // rewards are shared between orchestrator and registered paras

2239

1

            let orchestrator_rewards = all_rewards / 3;

2240

1

            assert_eq!(

2241

                orchestrator_rewards,

2242

1

                balance_after - balance_before,

2243

                "alice should get the correct reward portion"

2244

);

2245

1

});

2246

1

2247

2248

#[test]

2249

1

fn test_reward_to_invulnerable_with_key_change() {

2250

1

    ExtBuilder::default()

2251

1

        .with_balances(vec![

2252

1

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

2253

1

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

2254

1

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

2255

1

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

2256

1

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

2257

1

])

2258

1

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

2259

1

        .with_empty_parachains(vec![1001, 1002])

2260

1

        .build()

2261

1

        .execute_with(|| {

2262

1

            run_to_block(2);

2263

2264

1

            run_to_session(2u32);

2265

2266

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

2267

1

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

2268

1

            assert_ok!(Session::set_keys(

2269

1

                origin_of(ALICE.into()),

2270

1

                crate::SessionKeys {

2271

1

                    nimbus: alice_new_key,

2272

1

},

2273

1

                vec![]

2274

));

2275

2276

1

            run_to_session(4u32);

2277

2278

1

            let account: AccountId = ALICE.into();

2279

1

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

2280

2281

1

            let summary = run_block();

2282

1

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

2283

2284

1

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

2285

2286

1

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

2287

            // rewards are shared between orchestrator and registered paras

2288

1

            let orchestrator_rewards = all_rewards / 3;

2289

1

            assert_eq!(

2290

                orchestrator_rewards,

2291

1

                balance_after - balance_before,

2292

                "alice should get the correct reward portion"

2293

);

2294

1

});

2295

1

2296

2297

#[test]

2298

1

fn test_can_buy_credits_before_registering_para() {

2299

1

    ExtBuilder::default()

2300

1

        .with_balances(vec![

2301

1

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

2302

1

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

2303

1

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

2304

1

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

2305

1

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

2306

1

])

2307

1

        .with_collators(vec![

2308

1

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

2309

1

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

2310

1

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

2311

1

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

2312

1

])

2313

1

        .build()

2314

1

        .execute_with(|| {

2315

1

            run_to_block(2);

2316

2317

            // Try to buy the maximum amount of credits

2318

1

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

2319

1

            assert_ok!(ServicesPayment::purchase_credits(

2320

1

                origin_of(ALICE.into()),

2321

1

                1001.into(),

2322

1

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

2323

));

2324

1

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

2325

2326

            // Now parachain tank should have this amount

2327

1

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

2328

1

                .data

2329

1

                .free;

2330

2331

1

            assert_eq!(

2332

                balance_tank,

2333

1

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

2334

);

2335

2336

1

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

2337

1

            assert_eq!(balance_before - balance_after, expected_cost);

2338

1

});

2339

1

2340

2341

#[test]

2342

1

fn test_cannot_mark_valid_para_with_no_bootnodes() {

2343

1

    ExtBuilder::default()

2344

1

        .with_balances(vec![

2345

1

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

2346

1

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

2347

1

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

2348

1

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

2349

1

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

2350

1

])

2351

1

        .with_collators(vec![

2352

1

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

2353

1

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

2354

1

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

2355

1

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

2356

1

])

2357

1

        .build()

2358

1

        .execute_with(|| {

2359

1

            run_to_block(2);

2360

1

            assert_ok!(Registrar::register(

2361

1

                origin_of(ALICE.into()),

2362

1

                1001.into(),

2363

1

                empty_genesis_data(),

2364

1

                None

2365

));

2366

1

            assert_noop!(

2367

1

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

2368

1

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

2369

);

2370

1

});

2371

1

2372

2373

#[test]

2374

1

fn test_can_buy_credits_before_registering_para_and_receive_free_credits() {

2375

1

    ExtBuilder::default()

2376

1

        .with_balances(vec![

2377

1

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

2378

1

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

2379

1

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

2380

1

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

2381

1

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

2382

1

])

2383

1

        .with_collators(vec![

2384

1

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

2385

1

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

2386

1

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

2387

1

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

2388

1

])

2389

1

        .build()

2390

1

        .execute_with(|| {

2391

1

            run_to_block(2);

2392

2393

            // Try to buy (FreeBlockProductionCredits - 1) credits

2394

1

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

2395

1

            assert_ok!(ServicesPayment::purchase_credits(

2396

1

                origin_of(ALICE.into()),

2397

1

                1001.into(),

2398

1

                block_credits_to_required_balance(

2399

1

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

2400

1

                    1001.into()

2401

2402

));

2403

1

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

2404

2405

            // Now parachain tank should have this amount

2406

1

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

2407

1

                .data

2408

1

                .free;

2409

2410

1

            assert_eq!(

2411

                balance_tank,

2412

1

                block_credits_to_required_balance(

2413

1

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

2414

1

                    1001.into()

2415

2416

);

2417

2418

1

            let expected_cost = block_credits_to_required_balance(

2419

1

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

2420

1

                1001.into(),

2421

);

2422

1

            assert_eq!(balance_before - balance_after, expected_cost);

2423

2424

            // Now register para

2425

1

            assert_ok!(Registrar::register(

2426

1

                origin_of(ALICE.into()),

2427

1

                1001.into(),

2428

1

                empty_genesis_data(),

2429

1

                None

2430

));

2431

1

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

2432

1

            assert_ok!(Registrar::mark_valid_for_collating(

2433

1

                root_origin(),

2434

1

                1001.into()

2435

));

2436

2437

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

2438

1

            let credits =

2439

1

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

2440

1

                    .unwrap_or_default();

2441

1

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

2442

1

});

2443

1

2444

2445

#[test]

2446

1

fn test_deregister_and_register_again_does_not_give_free_credits() {

2447

1

    ExtBuilder::default()

2448

1

        .with_balances(vec![

2449

1

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

2450

1

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

2451

1

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

2452

1

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

2453

1

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

2454

1

])

2455

1

        .with_collators(vec![

2456

1

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

2457

1

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

2458

1

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

2459

1

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

2460

1

])

2461

1

        .build()

2462

1

        .execute_with(|| {

2463

1

            run_to_block(2);

2464

2465

            // Register

2466

1

            assert_ok!(Registrar::register(

2467

1

                origin_of(ALICE.into()),

2468

1

                1001.into(),

2469

1

                empty_genesis_data(),

2470

1

                None

2471

            ),);

2472

1

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

2473

1

            assert_ok!(Registrar::mark_valid_for_collating(

2474

1

                root_origin(),

2475

1

                1001.into()

2476

            ),);

2477

            // We received free credits

2478

1

            let credits =

2479

1

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

2480

1

                    .unwrap_or_default();

2481

1

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

2482

            // Deregister after 1 session

2483

1

            run_to_session(1);

2484

1

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

2485

2486

1

            run_to_session(3);

2487

1

            let credits_before_2nd_register =

2488

1

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

2489

1

                    .unwrap_or_default();

2490

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

2491

1

            assert_ne!(

2492

                credits_before_2nd_register,

2493

1

                crate::FreeBlockProductionCredits::get()

2494

);

2495

            // Register again

2496

1

            assert_ok!(Registrar::register(

2497

1

                origin_of(ALICE.into()),

2498

1

                1001.into(),

2499

1

                empty_genesis_data(),

2500

1

                None

2501

            ),);

2502

1

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

2503

1

            assert_ok!(Registrar::mark_valid_for_collating(

2504

1

                root_origin(),

2505

1

                1001.into()

2506

            ),);

2507

            // No more free credits

2508

1

            let credits =

2509

1

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

2510

1

                    .unwrap_or_default();

2511

1

            assert_eq!(credits, credits_before_2nd_register);

2512

1

});

2513

1

2514

2515

#[test]

2516

1

fn test_register_parathread_not_allowed() {

2517

1

    ExtBuilder::default()

2518

1

        .with_balances(vec![

2519

1

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

2520

1

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

2521

1

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

2522

1

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

2523

1

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

2524

1

])

2525

1

        .with_collators(vec![

2526

1

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

2527

1

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

2528

1

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

2529

1

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

2530

1

])

2531

1

        .build()

2532

1

        .execute_with(|| {

2533

1

            run_to_block(2);

2534

2535

1

            assert_noop!(

2536

1

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

2537

1

                    para_id: 3001.into(),

2538

1

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

2539

1

                    genesis_data: empty_genesis_data(),

2540

1

                    head_data: None

2541

1

})

2542

1

                .dispatch(

2543

1

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

2544

                        ALICE

2545

))

2546

),

2547

1

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

2548

);

2549

1

});

2550

1

2551

2552

#[test]

2553

1

fn test_register_parathread_genesis() {

2554

1

    let parathread_params = tp_traits::ParathreadParams {

2555

1

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

2556

1

};

2557

1

    ExtBuilder::default()

2558

1

        .with_balances(vec![

2559

1

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

2560

1

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

2561

1

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

2562

1

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

2563

1

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

2564

1

])

2565

1

        .with_collators(vec![

2566

1

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

2567

1

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

2568

1

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

2569

1

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

2570

1

])

2571

1

        .with_para_ids(vec![ParaRegistrationParams {

2572

1

            para_id: 3001,

2573

1

            genesis_data: empty_genesis_data(),

2574

1

            block_production_credits: u32::MAX,

2575

1

            collator_assignment_credits: u32::MAX,

2576

1

            parathread_params: Some(parathread_params.clone()),

2577

1

}])

2578

1

        .build()

2579

1

        .execute_with(|| {

2580

1

            run_to_block(2);

2581

2582

1

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

2583

1

            assert_eq!(

2584

1

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

2585

1

                Some(parathread_params)

2586

);

2587

2588

1

            let assignment = CollatorAssignment::collator_container_chain();

2589

1

            assert_eq!(

2590

1

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

2591

1

                vec![CHARLIE.into()]

2592

);

2593

1

});

2594

1

2595

2596

#[test]

2597

1

fn test_ed_plus_block_credit_session_purchase_works() {

2598

1

    ExtBuilder::default()

2599

1

        .with_balances(vec![

2600

1

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

2601

1

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

2602

1

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

2603

1

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

2604

1

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

2605

1

])

2606

1

        .with_collators(vec![

2607

1

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

2608

1

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

2609

1

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

2610

1

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

2611

1

])

2612

1

        .build()

2613

1

        .execute_with(|| {

2614

1

            run_to_block(2);

2615

            // Assert current slot gets updated

2616

1

            assert_eq!(current_slot(), 1u64);

2617

1

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

2618

2619

            // Alice and Bob collate in our chain

2620

1

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

2621

1

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

2622

2623

1

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

2624

2625

1

            assert_ok!(Registrar::register(

2626

1

                origin_of(ALICE.into()),

2627

1

                1001.into(),

2628

1

                empty_genesis_data(),

2629

1

                None

2630

));

2631

1

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

2632

1

            assert_ok!(Registrar::mark_valid_for_collating(

2633

1

                root_origin(),

2634

1

                1001.into()

2635

));

2636

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

2637

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2638

1

                root_origin(),

2639

1

                1001.into(),

2640

2641

));

2642

1

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

2643

1

                + crate::EXISTENTIAL_DEPOSIT;

2644

2645

            // Fill the tank

2646

1

            assert_ok!(ServicesPayment::purchase_credits(

2647

1

                origin_of(ALICE.into()),

2648

1

                1001.into(),

2649

1

                credits_1001

2650

));

2651

2652

            // Assignment should happen after 2 sessions

2653

1

            run_to_session(1u32);

2654

1

            let assignment = CollatorAssignment::collator_container_chain();

2655

1

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

2656

1

            run_to_session(2u32);

2657

            // Charlie and Dave should be assigned to para 1001

2658

1

            let assignment = CollatorAssignment::collator_container_chain();

2659

1

            assert_eq!(

2660

1

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

2661

1

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

2662

);

2663

2664

            // Simulate block inclusion from container chain 1001

2665

1

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

2666

1

            let slot: u64 = 5;

2667

1

            let s = ParaHeaderSproofBuilderItem {

2668

1

                para_id: 1001.into(),

2669

1

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

2670

1

                    parent_hash: Default::default(),

2671

1

                    number: 1,

2672

1

                    state_root: Default::default(),

2673

1

                    extrinsics_root: Default::default(),

2674

1

                    digest: sp_runtime::generic::Digest {

2675

1

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

2676

1

},

2677

1

}),

2678

1

};

2679

2680

1

            sproof.items.push(s);

2681

1

            set_author_noting_inherent_data(sproof);

2682

2683

1

            run_block();

2684

2685

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

2686

1

            run_to_session(3u32);

2687

            // Nobody should be assigned to para 1001

2688

1

            let assignment = CollatorAssignment::collator_container_chain();

2689

1

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

2690

1

});

2691

1

2692

2693

#[test]

2694

1

fn test_ed_plus_block_credit_session_minus_1_purchase_fails() {

2695

1

    ExtBuilder::default()

2696

1

        .with_balances(vec![

2697

1

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

2698

1

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

2699

1

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

2700

1

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

2701

1

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

2702

1

])

2703

1

        .with_collators(vec![

2704

1

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

2705

1

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

2706

1

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

2707

1

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

2708

1

])

2709

1

        .build()

2710

1

        .execute_with(|| {

2711

1

            run_to_block(2);

2712

            // Assert current slot gets updated

2713

1

            assert_eq!(current_slot(), 1u64);

2714

1

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

2715

2716

            // Alice and Bob collate in our chain

2717

1

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

2718

1

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

2719

2720

1

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

2721

2722

1

            assert_ok!(Registrar::register(

2723

1

                origin_of(ALICE.into()),

2724

1

                1001.into(),

2725

1

                empty_genesis_data(),

2726

1

                None

2727

));

2728

1

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

2729

1

            assert_ok!(Registrar::mark_valid_for_collating(

2730

1

                root_origin(),

2731

1

                1001.into()

2732

));

2733

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

2734

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2735

1

                root_origin(),

2736

1

                1001.into(),

2737

2738

));

2739

1

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

2740

1

                + crate::EXISTENTIAL_DEPOSIT

2741

1

                - 1;

2742

2743

            // Fill the tank

2744

1

            assert_ok!(ServicesPayment::purchase_credits(

2745

1

                origin_of(ALICE.into()),

2746

1

                1001.into(),

2747

1

                credits_1001

2748

));

2749

2750

            // Assignment should happen after 2 sessions

2751

1

            run_to_session(1u32);

2752

1

            let assignment = CollatorAssignment::collator_container_chain();

2753

1

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

2754

1

            run_to_session(2u32);

2755

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

2756

1

            let assignment = CollatorAssignment::collator_container_chain();

2757

1

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

2758

1

});

2759

1

2760

2761

#[test]

2762

1

fn test_reassignment_ed_plus_two_block_credit_session_purchase_works() {

2763

1

    ExtBuilder::default()

2764

1

        .with_balances(vec![

2765

1

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

2766

1

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

2767

1

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

2768

1

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

2769

1

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

2770

1

])

2771

1

        .with_collators(vec![

2772

1

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

2773

1

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

2774

1

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

2775

1

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

2776

1

])

2777

1

        .build()

2778

1

        .execute_with(|| {

2779

1

            run_to_block(2);

2780

            // Assert current slot gets updated

2781

1

            assert_eq!(current_slot(), 1u64);

2782

1

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

2783

2784

            // Alice and Bob collate in our chain

2785

1

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

2786

1

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

2787

2788

1

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

2789

2790

1

            assert_ok!(Registrar::register(

2791

1

                origin_of(ALICE.into()),

2792

1

                1001.into(),

2793

1

                empty_genesis_data(),

2794

1

                None

2795

));

2796

1

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

2797

1

            assert_ok!(Registrar::mark_valid_for_collating(

2798

1

                root_origin(),

2799

1

                1001.into()

2800

));

2801

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

2802

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2803

1

                root_origin(),

2804

1

                1001.into(),

2805

2806

));

2807

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

2808

1

            let credits_1001 =

2809

1

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

2810

1

                    + crate::EXISTENTIAL_DEPOSIT;

2811

2812

            // Fill the tank

2813

1

            assert_ok!(ServicesPayment::purchase_credits(

2814

1

                origin_of(ALICE.into()),

2815

1

                1001.into(),

2816

1

                credits_1001

2817

));

2818

2819

            // Assignment should happen after 2 sessions

2820

1

            run_to_session(1u32);

2821

1

            let assignment = CollatorAssignment::collator_container_chain();

2822

1

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

2823

2824

1

            run_to_session(2u32);

2825

            // Charlie and Dave should be assigned to para 1001

2826

1

            let assignment = CollatorAssignment::collator_container_chain();

2827

1

            assert_eq!(

2828

1

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

2829

1

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

2830

);

2831

2832

            // Simulate block inclusion from container chain 1001

2833

1

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

2834

1

            let slot: u64 = 5;

2835

1

            let s = ParaHeaderSproofBuilderItem {

2836

1

                para_id: 1001.into(),

2837

1

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

2838

1

                    parent_hash: Default::default(),

2839

1

                    number: 1,

2840

1

                    state_root: Default::default(),

2841

1

                    extrinsics_root: Default::default(),

2842

1

                    digest: sp_runtime::generic::Digest {

2843

1

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

2844

1

},

2845

1

}),

2846

1

};

2847

2848

1

            sproof.items.push(s);

2849

1

            set_author_noting_inherent_data(sproof);

2850

2851

1

            run_block();

2852

2853

            // Session 3 should still be assigned

2854

1

            run_to_session(3u32);

2855

            // Charlie and Dave should be assigned to para 1001

2856

1

            let assignment = CollatorAssignment::collator_container_chain();

2857

1

            assert_eq!(

2858

1

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

2859

1

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

2860

);

2861

2862

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

2863

1

            run_to_session(4u32);

2864

            // Nobody should be assigned to para 1001

2865

1

            let assignment = CollatorAssignment::collator_container_chain();

2866

1

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

2867

1

});

2868

1

2869

2870

#[test]

2871

1

fn test_reassignment_ed_plus_two_block_credit_session_minus_1_purchase_fails() {

2872

1

    ExtBuilder::default()

2873

1

        .with_balances(vec![

2874

1

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

2875

1

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

2876

1

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

2877

1

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

2878

1

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

2879

1

])

2880

1

        .with_collators(vec![

2881

1

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

2882

1

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

2883

1

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

2884

1

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

2885

1

])

2886

1

        .build()

2887

1

        .execute_with(|| {

2888

1

            run_to_block(2);

2889

            // Assert current slot gets updated

2890

1

            assert_eq!(current_slot(), 1u64);

2891

1

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

2892

2893

            // Alice and Bob collate in our chain

2894

1

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

2895

1

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

2896

2897

1

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

2898

2899

1

            assert_ok!(Registrar::register(

2900

1

                origin_of(ALICE.into()),

2901

1

                1001.into(),

2902

1

                empty_genesis_data(),

2903

1

                None

2904

));

2905

1

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

2906

1

            assert_ok!(Registrar::mark_valid_for_collating(

2907

1

                root_origin(),

2908

1

                1001.into()

2909

));

2910

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

2911

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2912

1

                root_origin(),

2913

1

                1001.into(),

2914

2915

));

2916

1

            let credits_1001 =

2917

1

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

2918

1

                    + crate::EXISTENTIAL_DEPOSIT

2919

1

                    - 1;

2920

2921

            // Fill the tank

2922

1

            assert_ok!(ServicesPayment::purchase_credits(

2923

1

                origin_of(ALICE.into()),

2924

1

                1001.into(),

2925

1

                credits_1001

2926

));

2927

2928

            // Assignment should happen after 2 sessions

2929

1

            run_to_session(1u32);

2930

1

            let assignment = CollatorAssignment::collator_container_chain();

2931

1

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

2932

2933

1

            run_to_session(2u32);

2934

            // Charlie and Dave should be assigned to para 1001

2935

1

            let assignment = CollatorAssignment::collator_container_chain();

2936

1

            assert_eq!(

2937

1

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

2938

1

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

2939

);

2940

2941

            // Simulate block inclusion from container chain 1001

2942

1

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

2943

1

            let slot: u64 = 5;

2944

1

            let s = ParaHeaderSproofBuilderItem {

2945

1

                para_id: 1001.into(),

2946

1

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

2947

1

                    parent_hash: Default::default(),

2948

1

                    number: 1,

2949

1

                    state_root: Default::default(),

2950

1

                    extrinsics_root: Default::default(),

2951

1

                    digest: sp_runtime::generic::Digest {

2952

1

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

2953

1

},

2954

1

}),

2955

1

};

2956

2957

1

            sproof.items.push(s);

2958

1

            set_author_noting_inherent_data(sproof);

2959

2960

1

            run_block();

2961

2962

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

2963

1

            run_to_session(3u32);

2964

            // Nobody should be assigned to para 1001

2965

1

            let assignment = CollatorAssignment::collator_container_chain();

2966

1

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

2967

1

});

2968

1

2969

2970

#[test]

2971

1

fn test_credits_with_purchase_can_be_combined() {

2972

1

    ExtBuilder::default()

2973

1

        .with_balances(vec![

2974

1

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

2975

1

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

2976

1

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

2977

1

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

2978

1

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

2979

1

])

2980

1

        .with_collators(vec![

2981

1

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

2982

1

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

2983

1

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

2984

1

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

2985

1

])

2986

1

        .build()

2987

1

        .execute_with(|| {

2988

1

            run_to_block(2);

2989

            // Assert current slot gets updated

2990

1

            assert_eq!(current_slot(), 1u64);

2991

1

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

2992

2993

            // Alice and Bob collate in our chain

2994

1

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

2995

1

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

2996

2997

1

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

2998

2999

1

            assert_ok!(Registrar::register(

3000

1

                origin_of(ALICE.into()),

3001

1

                1001.into(),

3002

1

                empty_genesis_data(),

3003

1

                None

3004

));

3005

1

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

3006

1

            assert_ok!(Registrar::mark_valid_for_collating(

3007

1

                root_origin(),

3008

1

                1001.into()

3009

));

3010

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

3011

1

            assert_ok!(ServicesPayment::set_block_production_credits(

3012

1

                root_origin(),

3013

1

                1001.into(),

3014

1

                crate::Period::get()

3015

));

3016

1

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

3017

1

                + crate::EXISTENTIAL_DEPOSIT;

3018

3019

            // Fill the tank

3020

1

            assert_ok!(ServicesPayment::purchase_credits(

3021

1

                origin_of(ALICE.into()),

3022

1

                1001.into(),

3023

1

                credits_1001

3024

));

3025

3026

            // Assignment should happen after 2 sessions

3027

1

            run_to_session(1u32);

3028

1

            let assignment = CollatorAssignment::collator_container_chain();

3029

1

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

3030

1

            run_to_session(2u32);

3031

            // Charlie and Dave should be assigned to para 1001

3032

1

            let assignment = CollatorAssignment::collator_container_chain();

3033

1

            assert_eq!(

3034

1

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

3035

1

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

3036

);

3037

1

});

3038

1

3039

#[test]

3040

1

fn stream_payment_works() {

3041

1

    ExtBuilder::default()

3042

1

        .with_balances(vec![

3043

1

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

3044

1

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

3045

1

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

3046

1

])

3047

1

        .with_collators(vec![

3048

1

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

3049

1

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

3050

1

])

3051

1

        .build()

3052

1

        .execute_with(|| {

3053

            use pallet_stream_payment::{ChangeKind, StreamConfig};

3054

3055

1

            assert_ok!(StreamPayment::open_stream(

3056

1

                origin_of(ALICE.into()),

3057

1

                BOB.into(),

3058

1

                StreamConfig {

3059

1

                    rate: 2 * UNIT,

3060

1

                    asset_id: StreamPaymentAssetId::Native,

3061

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

3062

1

                    minimum_request_deadline_delay: 0,

3063

1

                    soft_minimum_deposit: 0,

3064

1

},

3065

1

                1_000 * UNIT,

3066

));

3067

3068

1

            run_block();

3069

3070

1

            assert_ok!(StreamPayment::perform_payment(origin_of(CHARLIE.into()), 0));

3071

1

            assert_eq!(

3072

1

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

3073

                100_000 * UNIT + 2 * UNIT

3074

);

3075

3076

1

            assert_ok!(StreamPayment::request_change(

3077

1

                origin_of(ALICE.into()),

3078

0,

3079

1

                ChangeKind::Suggestion,

3080

1

                StreamConfig {

3081

1

                    rate: 1 * UNIT,

3082

1

                    asset_id: StreamPaymentAssetId::Native,

3083

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

3084

1

                    minimum_request_deadline_delay: 0,

3085

1

                    soft_minimum_deposit: 0,

3086

1

},

3087

1

                None,

3088

));

3089

3090

1

            assert_ok!(StreamPayment::accept_requested_change(

3091

1

                origin_of(BOB.into()),

3092

0,

3093

                1, // nonce

3094

1

                None,

3095

));

3096

3097

1

            run_block();

3098

3099

1

            assert_ok!(StreamPayment::close_stream(origin_of(BOB.into()), 0));

3100

3101

1

            assert_eq!(

3102

1

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

3103

                100_000 * UNIT + 3 * UNIT

3104

);

3105

1

            assert_eq!(

3106

1

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

3107

                100_000 * UNIT - 3 * UNIT

3108

);

3109

1

});

3110

1

3111

3112

#[test]

3113

1

fn test_ed_plus_collator_assignment_session_purchase_works() {

3114

1

    ExtBuilder::default()

3115

1

        .with_balances(vec![

3116

1

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

3117

1

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

3118

1

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

3119

1

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

3120

1

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

3121

1

])

3122

1

        .with_collators(vec![

3123

1

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

3124

1

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

3125

1

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

3126

1

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

3127

1

])

3128

1

        .build()

3129

1

        .execute_with(|| {

3130

1

            run_to_block(2);

3131

            // Assert current slot gets updated

3132

1

            assert_eq!(current_slot(), 1u64);

3133

1

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

3134

3135

            // Alice and Bob collate in our chain

3136

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3137

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3138

3139

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3140

3141

1

            assert_ok!(Registrar::register(

3142

1

                origin_of(ALICE.into()),

3143

1

                1001.into(),

3144

1

                empty_genesis_data(),

3145

1

                None

3146

));

3147

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3148

1

            assert_ok!(Registrar::mark_valid_for_collating(

3149

1

                root_origin(),

3150

1

                1001.into()

3151

));

3152

            // Need to reset credits to 0 because now parachains are given free credits on register

3153

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3154

1

                root_origin(),

3155

1

                1001.into(),

3156

3157

));

3158

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3159

1

                + crate::EXISTENTIAL_DEPOSIT;

3160

3161

            // Fill the tank

3162

1

            assert_ok!(ServicesPayment::purchase_credits(

3163

1

                origin_of(ALICE.into()),

3164

1

                1001.into(),

3165

1

                credits_1001

3166

));

3167

3168

            // Assignment should happen after 2 sessions

3169

1

            run_to_session(1u32);

3170

1

            let assignment = CollatorAssignment::collator_container_chain();

3171

1

            assert!(assignment.container_chains.is_empty());

3172

1

            run_to_session(2u32);

3173

            // Charlie and Dave should be assigned to para 1001

3174

1

            let assignment = CollatorAssignment::collator_container_chain();

3175

1

            assert_eq!(

3176

1

                assignment.container_chains[&1001u32.into()],

3177

1

                vec![CHARLIE.into(), DAVE.into()]

3178

);

3179

3180

            // Simulate block inclusion from container chain 1001

3181

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

3182

1

            let slot: u64 = 5;

3183

1

            let s = ParaHeaderSproofBuilderItem {

3184

1

                para_id: 1001.into(),

3185

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

3186

1

                    parent_hash: Default::default(),

3187

1

                    number: 1,

3188

1

                    state_root: Default::default(),

3189

1

                    extrinsics_root: Default::default(),

3190

1

                    digest: sp_runtime::generic::Digest {

3191

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

3192

1

},

3193

1

}),

3194

1

};

3195

1

            sproof.items.push(s);

3196

1

            set_author_noting_inherent_data(sproof);

3197

3198

1

            run_block();

3199

3200

            // After this it should not be assigned anymore, since credits are not payable

3201

1

            run_to_session(4u32);

3202

            // Nobody should be assigned to para 1001

3203

1

            let assignment = CollatorAssignment::collator_container_chain();

3204

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

3205

1

});

3206

1

3207

3208

#[test]

3209

1

fn test_ed_plus_collator_assignment_credit_session_minus_1_purchase_fails() {

3210

1

    ExtBuilder::default()

3211

1

        .with_balances(vec![

3212

1

            // Alice gets 10k extra tokens for her mapping deposit

3213

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3214

1

            (AccountId::from(BOB), 100_000 * UNIT),

3215

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3216

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3217

1

])

3218

1

        .with_collators(vec![

3219

1

            (AccountId::from(ALICE), 210 * UNIT),

3220

1

            (AccountId::from(BOB), 100 * UNIT),

3221

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3222

1

            (AccountId::from(DAVE), 100 * UNIT),

3223

1

])

3224

1

        .build()

3225

1

        .execute_with(|| {

3226

1

            run_to_block(2);

3227

            // Assert current slot gets updated

3228

1

            assert_eq!(current_slot(), 1u64);

3229

1

            assert!(current_author() == AccountId::from(BOB));

3230

3231

            // Alice and Bob collate in our chain

3232

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3233

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3234

3235

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3236

3237

1

            assert_ok!(Registrar::register(

3238

1

                origin_of(ALICE.into()),

3239

1

                1001.into(),

3240

1

                empty_genesis_data(),

3241

1

                None

3242

));

3243

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3244

1

            assert_ok!(Registrar::mark_valid_for_collating(

3245

1

                root_origin(),

3246

1

                1001.into()

3247

));

3248

            // Need to reset credits to 0 because now parachains are given free credits on register

3249

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3250

1

                root_origin(),

3251

1

                1001.into(),

3252

3253

));

3254

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3255

1

                + crate::EXISTENTIAL_DEPOSIT

3256

1

                - 1;

3257

3258

            // Fill the tank

3259

1

            assert_ok!(ServicesPayment::purchase_credits(

3260

1

                origin_of(ALICE.into()),

3261

1

                1001.into(),

3262

1

                credits_1001

3263

));

3264

3265

            // Assignment should happen after 2 sessions

3266

1

            run_to_session(1u32);

3267

1

            let assignment = CollatorAssignment::collator_container_chain();

3268

1

            assert!(assignment.container_chains.is_empty());

3269

1

            run_to_session(2u32);

3270

            // Charlie and Dave should not be assigned to para 1001

3271

1

            let assignment = CollatorAssignment::collator_container_chain();

3272

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

3273

1

});

3274

1

3275

3276

#[test]

3277

1

fn test_collator_assignment_credits_with_purchase_can_be_combined() {

3278

1

    ExtBuilder::default()

3279

1

        .with_balances(vec![

3280

1

            // Alice gets 10k extra tokens for her mapping deposit

3281

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3282

1

            (AccountId::from(BOB), 100_000 * UNIT),

3283

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3284

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3285

1

])

3286

1

        .with_collators(vec![

3287

1

            (AccountId::from(ALICE), 210 * UNIT),

3288

1

            (AccountId::from(BOB), 100 * UNIT),

3289

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3290

1

            (AccountId::from(DAVE), 100 * UNIT),

3291

1

])

3292

1

        .build()

3293

1

        .execute_with(|| {

3294

1

            run_to_block(2);

3295

            // Assert current slot gets updated

3296

1

            assert_eq!(current_slot(), 1u64);

3297

1

            assert!(current_author() == AccountId::from(BOB));

3298

3299

            // Alice and Bob collate in our chain

3300

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3301

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3302

3303

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3304

3305

1

            assert_ok!(Registrar::register(

3306

1

                origin_of(ALICE.into()),

3307

1

                1001.into(),

3308

1

                empty_genesis_data(),

3309

1

                None

3310

));

3311

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3312

1

            assert_ok!(Registrar::mark_valid_for_collating(

3313

1

                root_origin(),

3314

1

                1001.into()

3315

));

3316

3317

            // We assign one session to free credits

3318

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3319

1

                root_origin(),

3320

1

                1001.into(),

3321

3322

));

3323

            // We buy another session through the tank

3324

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3325

1

                + crate::EXISTENTIAL_DEPOSIT;

3326

3327

            // Fill the tank

3328

1

            assert_ok!(ServicesPayment::purchase_credits(

3329

1

                origin_of(ALICE.into()),

3330

1

                1001.into(),

3331

1

                credits_1001

3332

));

3333

3334

            // Assignment should happen after 2 sessions

3335

1

            run_to_session(1u32);

3336

1

            let assignment = CollatorAssignment::collator_container_chain();

3337

1

            assert!(assignment.container_chains.is_empty());

3338

1

            run_to_session(2u32);

3339

            // Charlie and Dave should be assigned to para 1001

3340

1

            let assignment = CollatorAssignment::collator_container_chain();

3341

1

            assert_eq!(

3342

1

                assignment.container_chains[&1001u32.into()],

3343

1

                vec![CHARLIE.into(), DAVE.into()]

3344

);

3345

1

});

3346

1

3347

3348

#[test]

3349

1

fn test_block_credits_and_collator_assignation_credits_through_tank() {

3350

1

    ExtBuilder::default()

3351

1

        .with_balances(vec![

3352

1

            // Alice gets 10k extra tokens for her mapping deposit

3353

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3354

1

            (AccountId::from(BOB), 100_000 * UNIT),

3355

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3356

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3357

1

])

3358

1

        .with_collators(vec![

3359

1

            (AccountId::from(ALICE), 210 * UNIT),

3360

1

            (AccountId::from(BOB), 100 * UNIT),

3361

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3362

1

            (AccountId::from(DAVE), 100 * UNIT),

3363

1

])

3364

1

        .build()

3365

1

        .execute_with(|| {

3366

1

            run_to_block(2);

3367

            // Assert current slot gets updated

3368

1

            assert_eq!(current_slot(), 1u64);

3369

1

            assert!(current_author() == AccountId::from(BOB));

3370

3371

            // Alice and Bob collate in our chain

3372

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3373

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3374

3375

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3376

3377

1

            assert_ok!(Registrar::register(

3378

1

                origin_of(ALICE.into()),

3379

1

                1001.into(),

3380

1

                empty_genesis_data(),

3381

1

                None

3382

));

3383

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3384

1

            assert_ok!(Registrar::mark_valid_for_collating(

3385

1

                root_origin(),

3386

1

                1001.into()

3387

));

3388

3389

            // We make all free credits 0

3390

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3391

1

                root_origin(),

3392

1

                1001.into(),

3393

3394

));

3395

1

            assert_ok!(ServicesPayment::set_block_production_credits(

3396

1

                root_origin(),

3397

1

                1001.into(),

3398

3399

));

3400

3401

            // We buy 2 sessions through tank

3402

1

            let collator_assignation_credits =

3403

1

                collator_assignment_credits_to_required_balance(2, 1001.into());

3404

1

            let block_production_credits =

3405

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into());

3406

3407

            // Fill the tank

3408

1

            assert_ok!(ServicesPayment::purchase_credits(

3409

1

                origin_of(ALICE.into()),

3410

1

                1001.into(),

3411

1

                collator_assignation_credits

3412

1

                    + block_production_credits

3413

1

                    + crate::EXISTENTIAL_DEPOSIT

3414

));

3415

3416

            // Assignment should happen after 2 sessions

3417

1

            run_to_session(1u32);

3418

1

            let assignment = CollatorAssignment::collator_container_chain();

3419

1

            assert!(assignment.container_chains.is_empty());

3420

1

            run_to_session(2u32);

3421

            // Charlie and Dave should be assigned to para 1001

3422

1

            let assignment = CollatorAssignment::collator_container_chain();

3423

1

            assert_eq!(

3424

1

                assignment.container_chains[&1001u32.into()],

3425

1

                vec![CHARLIE.into(), DAVE.into()]

3426

);

3427

3428

            // After this it should not be assigned anymore, since credits are not payable

3429

1

            run_to_session(4u32);

3430

            // Nobody should be assigned to para 1001

3431

1

            let assignment = CollatorAssignment::collator_container_chain();

3432

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

3433

1

});

3434

1

3435

3436

#[test]

3437

1

fn test_migration_services_collator_assignment_payment() {

3438

1

    ExtBuilder::default().build().execute_with(|| {

3439

        // Register a new parachain with no credits

3440

1

        assert_ok!(Registrar::register(

3441

1

            origin_of(ALICE.into()),

3442

1

            1001.into(),

3443

1

            empty_genesis_data(),

3444

1

            None

3445

));

3446

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3447

1

        assert_ok!(Registrar::mark_valid_for_collating(

3448

1

            root_origin(),

3449

1

            1001.into()

3450

));

3451

        // Register another parachain with no credits, do not mark this as valid for collation

3452

1

        assert_ok!(Registrar::register(

3453

1

            origin_of(ALICE.into()),

3454

1

            1002.into(),

3455

1

            empty_genesis_data(),

3456

1

            None

3457

));

3458

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1002.into());

3459

1

        assert_ok!(Registrar::mark_valid_for_collating(

3460

1

            root_origin(),

3461

1

            1002.into()

3462

));

3463

3464

        // Need to reset credits to 0 because now parachains are given free credits on register

3465

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

3466

1

            root_origin(),

3467

1

            1001.into(),

3468

3469

));

3470

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

3471

1

            root_origin(),

3472

1

            1002.into(),

3473

3474

));

3475

3476

1

        let credits_1001 =

3477

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

3478

1

                .unwrap_or_default();

3479

1

        assert_eq!(credits_1001, 0);

3480

1

        let credits_1002 =

3481

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

3482

1

                .unwrap_or_default();

3483

1

        assert_eq!(credits_1002, 0);

3484

3485

        // Apply migration

3486

1

        let migration =

3487

1

            MigrateServicesPaymentAddCollatorAssignmentCredits::<Runtime>(Default::default());

3488

1

        migration.migrate(Default::default());

3489

3490

        // Both parachains have been given credits

3491

1

        let credits_1001 =

3492

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

3493

1

                .unwrap_or_default();

3494

1

        assert_eq!(credits_1001, crate::FreeCollatorAssignmentCredits::get());

3495

1

        let credits_1002 =

3496

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

3497

1

                .unwrap_or_default();

3498

1

        assert_eq!(credits_1002, crate::FreeCollatorAssignmentCredits::get());

3499

1

});

3500

1

3501

3502

#[test]

3503

1

fn test_max_collators_uses_pending_value() {

3504

    // Start with max_collators = 100, and collators_per_container = 2

3505

    // Set max_collators = 2, and collators_per_container = 3

3506

    // It should be impossible to have more than 2 collators per container at any point in time

3507

1

    ExtBuilder::default()

3508

1

        .with_balances(vec![

3509

1

            // Alice gets 10k extra tokens for her mapping deposit

3510

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3511

1

            (AccountId::from(BOB), 100_000 * UNIT),

3512

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3513

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3514

1

])

3515

1

        .with_collators(vec![

3516

1

            (AccountId::from(ALICE), 210 * UNIT),

3517

1

            (AccountId::from(BOB), 100 * UNIT),

3518

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3519

1

            (AccountId::from(DAVE), 100 * UNIT),

3520

1

])

3521

1

        .with_empty_parachains(vec![1001])

3522

1

        .with_config(pallet_configuration::HostConfiguration {

3523

1

            max_collators: 100,

3524

1

            min_orchestrator_collators: 1,

3525

1

            max_orchestrator_collators: 1,

3526

1

            collators_per_container: 2,

3527

1

            full_rotation_period: 24,

3528

1

            ..Default::default()

3529

1

})

3530

1

        .build()

3531

1

        .execute_with(|| {

3532

1

            run_to_block(2);

3533

3534

            // Initial assignment: 1 collator in orchestrator chain and 2 collators in container 1001

3535

1

            let assignment = CollatorAssignment::collator_container_chain();

3536

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 2);

3537

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

3538

3539

1

            assert_ok!(Configuration::set_max_collators(root_origin(), 2));

3540

1

            assert_ok!(Configuration::set_collators_per_container(root_origin(), 3));

3541

3542

            // Check invariant for all intermediate assignments. We set collators_per_container = 3

3543

            // but we also set max_collators = 2, so no collators will be assigned to container

3544

            // chains after the change is applied.

3545

5

            for session in 1..=4 {

3546

4

                run_to_session(session);

3547

3548

4

                let assignment = CollatorAssignment::collator_container_chain();

3549

4

                assert!(

3550

4

                    assignment.container_chains[&1001u32.into()].len() <= 2,

3551

                    "session {}: {} collators assigned to container chain 1001",

3552

                    session,

3553

                    assignment.container_chains[&1001u32.into()].len()

3554

);

3555

3556

3557

            // Final assignment: because max_collators = 2, there are only 2 collators, one in

3558

            // orchestrator chain, and the other one idle

3559

1

            let assignment = CollatorAssignment::collator_container_chain();

3560

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 0);

3561

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

3562

1

});

3563

1

3564

3565

#[test]

3566

1

fn test_slow_adjusting_multiplier_changes_in_response_to_consumed_weight() {

3567

1

    ExtBuilder::default()

3568

1

        .with_collators(vec![

3569

1

            (AccountId::from(ALICE), 210 * UNIT),

3570

1

            (AccountId::from(BOB), 100 * UNIT),

3571

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3572

1

            (AccountId::from(DAVE), 100 * UNIT),

3573

1

])

3574

1

        .build()

3575

1

        .execute_with(|| {

3576

1

            end_block();

3577

            // If the block is full, the multiplier increases

3578

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

3579

1

            start_block();

3580

1

            let max_block_weights = crate::RuntimeBlockWeights::get();

3581

1

            frame_support::storage::unhashed::put(

3582

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

3583

3

                &ConsumedWeight::new(|class| {

3584

3

                    max_block_weights

3585

3

                        .get(class)

3586

3

                        .max_total

3587

3

                        .unwrap_or(Weight::MAX)

3588

3

}),

3589

);

3590

1

            end_block();

3591

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

3592

1

            assert!(current_multiplier > before_multiplier);

3593

3594

            // If the block is empty, the multiplier decreases

3595

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

3596

1

            start_block();

3597

1

            frame_support::storage::unhashed::put(

3598

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

3599

3

                &ConsumedWeight::new(|_class| Weight::zero()),

3600

);

3601

1

            end_block();

3602

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

3603

1

            assert!(current_multiplier < before_multiplier);

3604

1

});

3605

1

3606

3607

#[test]

3608

1

fn test_collator_assignment_tip_priority_on_congestion() {

3609

1

    ExtBuilder::default()

3610

1

        .with_balances(vec![

3611

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3612

1

            (AccountId::from(BOB), 100_000 * UNIT),

3613

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3614

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3615

1

])

3616

1

        .with_collators(vec![

3617

1

            (AccountId::from(ALICE), 210 * UNIT),

3618

1

            (AccountId::from(BOB), 100 * UNIT),

3619

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3620

1

            (AccountId::from(DAVE), 100 * UNIT),

3621

1

])

3622

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3623

1

        .build()

3624

1

        .execute_with(|| {

3625

1

            let para_id = 1003u32;

3626

1

            let tank_funds = 100 * UNIT;

3627

1

            let max_tip = 1 * UNIT;

3628

3629

1

            assert_eq!(

3630

1

                CollatorAssignment::collator_container_chain().container_chains[&1003u32.into()]

3631

1

                    .len(),

3632

3633

);

3634

3635

            // Send funds to tank

3636

1

            assert_ok!(ServicesPayment::purchase_credits(

3637

1

                origin_of(ALICE.into()),

3638

1

                para_id.into(),

3639

1

                tank_funds,

3640

));

3641

3642

            // Set tip for 1003

3643

1

            assert_ok!(ServicesPayment::set_max_tip(

3644

1

                root_origin(),

3645

1

                para_id.into(),

3646

1

                Some(max_tip),

3647

));

3648

3649

1

            run_to_session(2);

3650

1

            assert_eq!(

3651

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

3652

1

                    .len(),

3653

2,

3654

);

3655

1

});

3656

1

3657

3658

#[test]

3659

1

fn test_collator_assignment_tip_charged_on_congestion() {

3660

1

    ExtBuilder::default()

3661

1

        .with_balances(vec![

3662

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3663

1

            (AccountId::from(BOB), 100_000 * UNIT),

3664

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3665

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3666

1

])

3667

1

        .with_collators(vec![

3668

1

            (AccountId::from(ALICE), 210 * UNIT),

3669

1

            (AccountId::from(BOB), 100 * UNIT),

3670

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3671

1

            (AccountId::from(DAVE), 100 * UNIT),

3672

1

])

3673

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3674

1

        .build()

3675

1

        .execute_with(|| {

3676

1

            let tank_funds = 100 * UNIT;

3677

1

            let max_tip = 1 * UNIT;

3678

1

            let para_id = 1003u32;

3679

3680

            // Send funds to tank

3681

1

            assert_ok!(ServicesPayment::purchase_credits(

3682

1

                origin_of(ALICE.into()),

3683

1

                para_id.into(),

3684

1

                tank_funds,

3685

));

3686

3687

            // Set tip for para_id

3688

1

            assert_ok!(ServicesPayment::set_max_tip(

3689

1

                root_origin(),

3690

1

                para_id.into(),

3691

1

                Some(max_tip),

3692

));

3693

3694

1

            run_to_session(1);

3695

1

            assert_eq!(

3696

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id.into())),

3697

1

                tank_funds - max_tip,

3698

);

3699

1

});

3700

1

3701

3702

#[test]

3703

1

fn test_collator_assignment_tip_not_assigned_on_insufficient_balance() {

3704

1

    ExtBuilder::default()

3705

1

        .with_balances(vec![

3706

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3707

1

            (AccountId::from(BOB), 100_000 * UNIT),

3708

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3709

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3710

1

])

3711

1

        .with_collators(vec![

3712

1

            (AccountId::from(ALICE), 210 * UNIT),

3713

1

            (AccountId::from(BOB), 100 * UNIT),

3714

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3715

1

            (AccountId::from(DAVE), 100 * UNIT),

3716

1

])

3717

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3718

1

        .build()

3719

1

        .execute_with(|| {

3720

1

            let tank_funds = 1 * UNIT;

3721

1

            let max_tip = 1 * UNIT;

3722

1

            let para_id = 1003u32;

3723

3724

            // Send insufficient funds to tank for tip for 2 sessions

3725

1

            assert_ok!(ServicesPayment::purchase_credits(

3726

1

                origin_of(ALICE.into()),

3727

1

                para_id.into(),

3728

1

                tank_funds,

3729

));

3730

3731

            // Set tip for para_id

3732

1

            assert_ok!(ServicesPayment::set_max_tip(

3733

1

                root_origin(),

3734

1

                para_id.into(),

3735

1

                Some(max_tip),

3736

));

3737

3738

1

            run_to_session(1);

3739

1

            assert_eq!(

3740

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

3741

1

                    .len(),

3742

3743

);

3744

1

});

3745

1

3746

3747

#[test]

3748

1

fn test_collator_assignment_tip_only_charge_willing_paras() {

3749

1

    ExtBuilder::default()

3750

1

        .with_balances(vec![

3751

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3752

1

            (AccountId::from(BOB), 100_000 * UNIT),

3753

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3754

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3755

1

            (AccountId::from(EVE), 100_000 * UNIT),

3756

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

3757

1

])

3758

1

        .with_collators(vec![

3759

1

            (AccountId::from(ALICE), 210 * UNIT),

3760

1

            (AccountId::from(BOB), 100 * UNIT),

3761

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3762

1

            (AccountId::from(DAVE), 100 * UNIT),

3763

1

            (AccountId::from(EVE), 100 * UNIT),

3764

1

            (AccountId::from(FERDIE), 100 * UNIT),

3765

1

])

3766

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3767

1

        .build()

3768

1

        .execute_with(|| {

3769

1

            let tank_funds = 100 * UNIT;

3770

1

            let max_tip = 1 * UNIT;

3771

1

            let para_id_with_tip = 1003u32;

3772

1

            let para_id_without_tip = 1001u32;

3773

3774

            // Send funds to tank to both paras

3775

1

            assert_ok!(ServicesPayment::purchase_credits(

3776

1

                origin_of(ALICE.into()),

3777

1

                para_id_with_tip.into(),

3778

1

                tank_funds,

3779

));

3780

1

            assert_ok!(ServicesPayment::purchase_credits(

3781

1

                origin_of(ALICE.into()),

3782

1

                para_id_without_tip.into(),

3783

1

                tank_funds,

3784

));

3785

3786

            // Only set tip for 1003

3787

1

            assert_ok!(ServicesPayment::set_max_tip(

3788

1

                root_origin(),

3789

1

                para_id_with_tip.into(),

3790

1

                Some(max_tip),

3791

));

3792

3793

1

            run_to_session(2);

3794

3795

1

            let assignment = CollatorAssignment::collator_container_chain().container_chains;

3796

3797

            // 2 out of the 3 paras should have collators assigned, with one paying tip to get

3798

            // prioritized, and the other selected at random that should not be charged any tips

3799

1

            assert_eq!(assignment[&para_id_with_tip.into()].len(), 2);

3800

1

            assert_eq!(

3801

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_with_tip.into())),

3802

1

                tank_funds - max_tip * 2,

3803

);

3804

3805

1

            assert_eq!(assignment[&para_id_without_tip.into()].len(), 2);

3806

1

            assert_eq!(

3807

1

                Balances::usable_balance(ServicesPayment::parachain_tank(

3808

1

                    para_id_without_tip.into()

3809

)),

3810

                tank_funds,

3811

);

3812

1

});

3813

1

3814

3815

#[test]

3816

1

fn test_collator_assignment_tip_withdraw_min_tip() {

3817

1

    ExtBuilder::default()

3818

1

        .with_balances(vec![

3819

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3820

1

            (AccountId::from(BOB), 100_000 * UNIT),

3821

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3822

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3823

1

            (AccountId::from(EVE), 100_000 * UNIT),

3824

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

3825

1

])

3826

1

        .with_collators(vec![

3827

1

            (AccountId::from(ALICE), 210 * UNIT),

3828

1

            (AccountId::from(BOB), 100 * UNIT),

3829

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3830

1

            (AccountId::from(DAVE), 100 * UNIT),

3831

1

            (AccountId::from(EVE), 100 * UNIT),

3832

1

            (AccountId::from(FERDIE), 100 * UNIT),

3833

1

])

3834

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3835

1

        .build()

3836

1

        .execute_with(|| {

3837

1

            let tank_funds = 100 * UNIT;

3838

1

            let max_tip_1003 = 3 * UNIT;

3839

1

            let max_tip_1002 = 2 * UNIT;

3840

1

            let para_id_1003 = 1003u32;

3841

1

            let para_id_1002 = 1002u32;

3842

3843

            // Send funds to tank to both paras

3844

1

            assert_ok!(ServicesPayment::purchase_credits(

3845

1

                origin_of(ALICE.into()),

3846

1

                para_id_1003.into(),

3847

1

                tank_funds,

3848

));

3849

1

            assert_ok!(ServicesPayment::purchase_credits(

3850

1

                origin_of(ALICE.into()),

3851

1

                para_id_1002.into(),

3852

1

                tank_funds,

3853

));

3854

3855

            // Set tips

3856

1

            assert_ok!(ServicesPayment::set_max_tip(

3857

1

                root_origin(),

3858

1

                para_id_1003.into(),

3859

1

                Some(max_tip_1003),

3860

));

3861

1

            assert_ok!(ServicesPayment::set_max_tip(

3862

1

                root_origin(),

3863

1

                para_id_1002.into(),

3864

1

                Some(max_tip_1002),

3865

));

3866

3867

1

            run_to_session(2);

3868

3869

1

            assert_eq!(

3870

1

                CollatorAssignment::collator_container_chain().container_chains

3871

1

                    [&para_id_1003.into()]

3872

1

                    .len(),

3873

3874

);

3875

1

            assert_eq!(

3876

1

                CollatorAssignment::collator_container_chain().container_chains

3877

1

                    [&para_id_1002.into()]

3878

1

                    .len(),

3879

3880

);

3881

3882

            // Should have withdrawn the lowest tip from both paras

3883

1

            assert_eq!(

3884

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1003.into())),

3885

1

                tank_funds - max_tip_1002 * 2,

3886

);

3887

3888

1

            assert_eq!(

3889

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1002.into())),

3890

1

                tank_funds - max_tip_1002 * 2,

3891

);

3892

1

});

3893

1

3894

3895

#[test]

3896

1

fn test_migration_data_preservers_profile_content() {

3897

1

    ExtBuilder::default()

3898

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

3899

1

        .build()

3900

1

        .execute_with(|| {

3901

            use frame_support::{migration::put_storage_value, Blake2_128Concat, StorageHasher};

3902

            use pallet_data_preservers::{

3903

                migrations::{OldProfile, OldRegisteredProfile, ProfileMode},

3904

                NodeType, ParaIdsFilter, Profile, RegisteredProfile,

3905

};

3906

            use sp_runtime::traits::Zero;

3907

            use tanssi_runtime_common::migrations::DataPreserversProfileContentMigration;

3908

            use tp_stream_payment_common::AssetId;

3909

3910

1

            let bootnode_profile = OldRegisteredProfile::<Runtime> {

3911

1

                account: ALICE.into(),

3912

1

                deposit: 42u128,

3913

1

                assignment: None,

3914

1

                profile: OldProfile {

3915

1

                    url: b"alice".to_vec().try_into().unwrap(),

3916

1

                    para_ids: ParaIdsFilter::AnyParaId,

3917

1

                    assignment_request: tp_data_preservers_common::ProviderRequest::Free,

3918

1

                    mode: ProfileMode::Bootnode,

3919

1

},

3920

1

};

3921

3922

1

            let substrate_rpc_profile = OldRegisteredProfile::<Runtime> {

3923

1

                account: BOB.into(),

3924

1

                deposit: 43u128,

3925

1

                assignment: Some((

3926

1

                    ParaId::from(1042),

3927

1

                    tp_data_preservers_common::AssignmentWitness::Free,

3928

1

)),

3929

1

3930

1

                profile: OldProfile {

3931

1

                    url: b"bob".to_vec().try_into().unwrap(),

3932

1

                    para_ids: ParaIdsFilter::AnyParaId,

3933

1

                    assignment_request: tp_data_preservers_common::ProviderRequest::Free,

3934

1

                    mode: ProfileMode::Rpc {

3935

1

                        supports_ethereum_rpcs: false,

3936

1

},

3937

1

},

3938

1

};

3939

3940

1

            let stream_config = pallet_stream_payment::StreamConfig {

3941

1

                time_unit: tp_stream_payment_common::TimeUnit::BlockNumber,

3942

1

                asset_id: AssetId::Native,

3943

1

                rate: 100u128,

3944

1

                minimum_request_deadline_delay: Zero::zero(),

3945

1

                soft_minimum_deposit: Zero::zero(),

3946

1

};

3947

1

            let frontier_rpc_profile = OldRegisteredProfile::<Runtime> {

3948

1

                account: CHARLIE.into(),

3949

1

                deposit: 44u128,

3950

1

                assignment: Some((

3951

1

                    ParaId::from(1043),

3952

1

                    tp_data_preservers_common::AssignmentWitness::StreamPayment { stream_id: 200 },

3953

1

)),

3954

1

                profile: OldProfile {

3955

1

                    url: b"charlie".to_vec().try_into().unwrap(),

3956

1

                    para_ids: ParaIdsFilter::AnyParaId,

3957

1

                    assignment_request: tp_data_preservers_common::ProviderRequest::StreamPayment {

3958

1

                        config: stream_config,

3959

1

},

3960

1

                    mode: ProfileMode::Rpc {

3961

1

                        supports_ethereum_rpcs: true,

3962

1

},

3963

1

},

3964

1

};

3965

3966

1

            let pallet_prefix: &[u8] = b"DataPreservers";

3967

1

            let storage_item_prefix: &[u8] = b"Profiles";

3968

3969

1

            put_storage_value(

3970

1

                pallet_prefix,

3971

1

                storage_item_prefix,

3972

1

                &Blake2_128Concat::hash(&0u64.encode()),

3973

1

                bootnode_profile,

3974

);

3975

1

            put_storage_value(

3976

1

                pallet_prefix,

3977

1

                storage_item_prefix,

3978

1

                &Blake2_128Concat::hash(&1u64.encode()),

3979

1

                substrate_rpc_profile,

3980

);

3981

1

            put_storage_value(

3982

1

                pallet_prefix,

3983

1

                storage_item_prefix,

3984

1

                &Blake2_128Concat::hash(&2u64.encode()),

3985

1

                frontier_rpc_profile,

3986

);

3987

3988

1

            let migration = DataPreserversProfileContentMigration::<Runtime>(Default::default());

3989

1

            migration.migrate(Default::default());

3990

3991

1

            assert_eq!(

3992

1

                pallet_data_preservers::Profiles::<Runtime>::get(0),

3993

1

                Some(RegisteredProfile {

3994

1

                    account: ALICE.into(),

3995

1

                    deposit: 42u128,

3996

1

                    assignment: None,

3997

1

                    profile: Profile {

3998

1

                        para_ids: ParaIdsFilter::AnyParaId,

3999

1

                        assignment_request: tp_data_preservers_common::ProviderRequest::Free,

4000

1

                        node_type: NodeType::Substrate,

4001

1

                        additional_info: Default::default(),

4002

1

                        direct_rpc_urls: Default::default(),

4003

1

                        proxy_rpc_urls: Default::default(),

4004

1

                        bootnode_url: Some(b"alice".to_vec().try_into().unwrap())

4005

1

4006

1

})

4007

);

4008

4009

1

            assert_eq!(

4010

1

                pallet_data_preservers::Profiles::<Runtime>::get(1),

4011

1

                Some(RegisteredProfile {

4012

1

                    account: BOB.into(),

4013

1

                    deposit: 43u128,

4014

1

                    assignment: Some((

4015

1

                        ParaId::from(1042),

4016

1

                        tp_data_preservers_common::AssignmentWitness::Free

4017

1

)),

4018

1

                    profile: Profile {

4019

1

                        para_ids: ParaIdsFilter::AnyParaId,

4020

1

                        assignment_request: tp_data_preservers_common::ProviderRequest::Free,

4021

1

                        node_type: NodeType::Substrate,

4022

1

                        additional_info: Default::default(),

4023

1

                        direct_rpc_urls: {

4024

1

                            let url = b"bob".to_vec().try_into().unwrap();

4025

1

                            let urls = vec![url].try_into().unwrap();

4026

1

                            urls

4027

1

},

4028

1

                        proxy_rpc_urls: Default::default(),

4029

1

                        bootnode_url: None

4030

1

4031

1

})

4032

);

4033

4034

1

            assert_eq!(

4035

1

                pallet_data_preservers::Profiles::<Runtime>::get(2),

4036

1

                Some(RegisteredProfile {

4037

1

                    account: CHARLIE.into(),

4038

1

                    deposit: 44u128,

4039

1

                    assignment: Some((

4040

1

                        ParaId::from(1043),

4041

1

                        tp_data_preservers_common::AssignmentWitness::StreamPayment {

4042

1

                            stream_id: 200,

4043

1

4044

1

)),

4045

1

                    profile: Profile {

4046

1

                        para_ids: ParaIdsFilter::AnyParaId,

4047

1

                        assignment_request:

4048

1

                            tp_data_preservers_common::ProviderRequest::StreamPayment {

4049

1

                                config: stream_config

4050

1

},

4051

1

                        node_type: NodeType::Frontier,

4052

1

                        additional_info: Default::default(),

4053

1

                        direct_rpc_urls: {

4054

1

                            let url = b"charlie".to_vec().try_into().unwrap();

4055

1

                            let urls = vec![url].try_into().unwrap();

4056

1

                            urls

4057

1

},

4058

1

                        proxy_rpc_urls: Default::default(),

4059

1

                        bootnode_url: None

4060

1

4061

1

})

4062

);

4063

1

})

4064

1

4065

4066

#[test]

4067

1

fn test_migration_registrar_reserves_to_hold() {

4068

1

    ExtBuilder::default()

4069

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

4070

1

        .build()

4071

1

        .execute_with(|| {

4072

            use {

4073

                frame_support::traits::{fungible::InspectHold, ReservableCurrency},

4074

                pallet_registrar::DepositInfo,

4075

                tanssi_runtime_common::migrations::RegistrarReserveToHoldMigration,

4076

};

4077

4078

1

            let deposit: Balance = 100 * UNIT;

4079

1

            let account: AccountId = DAVE.into();

4080

4081

1

            assert_ok!(Balances::reserve(&account, deposit));

4082

4083

1

            pallet_registrar::RegistrarDeposit::<Runtime>::insert(

4084

1

                ParaId::from(1001),

4085

1

                DepositInfo {

4086

1

                    creator: account.clone(),

4087

1

                    deposit,

4088

1

},

4089

);

4090

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

4091

            // Apply migration

4092

1

            let migration = RegistrarReserveToHoldMigration::<Runtime>(Default::default());

4093

1

            migration.migrate(Default::default());

4094

4095

            // Holds also count as reserved balance, so the total reserved amount

4096

            // shouldn't change after the migration

4097

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

4098

4099

1

            assert_eq!(

4100

1

                Balances::balance_on_hold(

4101

1

                    &pallet_registrar::HoldReason::RegistrarDeposit.into(),

4102

1

                    &account

4103

),

4104

                deposit

4105

);

4106

1

})

4107

1

4108

4109

#[test]

4110

1

fn test_migration_stream_payment_config_new_fields() {

4111

1

    ExtBuilder::default().build().execute_with(|| {

4112

        use pallet_stream_payment::{

4113

            migrations::{OldChangeRequest, OldStream, OldStreamConfig},

4114

            ChangeKind, ChangeRequest, DepositChange, Party, Stream, StreamConfig,

4115

};

4116

        use tanssi_runtime_common::migrations::MigrateStreamPaymentNewConfigFields;

4117

4118

1

        frame_support::storage::unhashed::put(

4119

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(0),

4120

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

4121

1

                source: ALICE.into(),

4122

1

                target: BOB.into(),

4123

1

                config: OldStreamConfig {

4124

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4125

1

                    asset_id: StreamPaymentAssetId::Native,

4126

1

                    rate: 41,

4127

1

},

4128

1

                deposit: 42,

4129

1

                last_time_updated: 43,

4130

1

                request_nonce: 44,

4131

1

                pending_request: Some(OldChangeRequest {

4132

1

                    requester: Party::Source,

4133

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

4134

1

                    new_config: OldStreamConfig {

4135

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

4136

1

                        asset_id: StreamPaymentAssetId::Native,

4137

1

                        rate: 46,

4138

1

},

4139

1

                    deposit_change: Some(DepositChange::Absolute(47)),

4140

1

}),

4141

1

                opening_deposit: 48,

4142

1

},

4143

);

4144

4145

1

        frame_support::storage::unhashed::put(

4146

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(1),

4147

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

4148

1

                source: CHARLIE.into(),

4149

1

                target: ALICE.into(),

4150

1

                config: OldStreamConfig {

4151

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4152

1

                    asset_id: StreamPaymentAssetId::Native,

4153

1

                    rate: 100,

4154

1

},

4155

1

                deposit: 101,

4156

1

                last_time_updated: 102,

4157

1

                request_nonce: 103,

4158

1

                pending_request: None,

4159

1

                opening_deposit: 104,

4160

1

},

4161

);

4162

4163

1

        let migration = MigrateStreamPaymentNewConfigFields::<Runtime>(Default::default());

4164

1

        migration.migrate(Default::default());

4165

4166

1

        assert_eq!(

4167

1

            pallet_stream_payment::Streams::<Runtime>::get(0).unwrap(),

4168

1

            Stream {

4169

1

                source: ALICE.into(),

4170

1

                target: BOB.into(),

4171

1

                config: StreamConfig {

4172

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4173

1

                    asset_id: StreamPaymentAssetId::Native,

4174

1

                    rate: 41,

4175

1

                    minimum_request_deadline_delay: 0,

4176

1

                    soft_minimum_deposit: 0,

4177

1

},

4178

1

                deposit: 42,

4179

1

                last_time_updated: 43,

4180

1

                request_nonce: 44,

4181

1

                pending_request: Some(ChangeRequest {

4182

1

                    requester: Party::Source,

4183

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

4184

1

                    new_config: StreamConfig {

4185

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

4186

1

                        asset_id: StreamPaymentAssetId::Native,

4187

1

                        rate: 46,

4188

1

                        minimum_request_deadline_delay: 0,

4189

1

                        soft_minimum_deposit: 0,

4190

1

},

4191

1

                    deposit_change: Some(DepositChange::Absolute(47)),

4192

1

}),

4193

1

                opening_deposit: 48,

4194

1

4195

);

4196

4197

1

        assert_eq!(

4198

1

            pallet_stream_payment::Streams::<Runtime>::get(1).unwrap(),

4199

1

            Stream {

4200

1

                source: CHARLIE.into(),

4201

1

                target: ALICE.into(),

4202

1

                config: StreamConfig {

4203

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4204

1

                    asset_id: StreamPaymentAssetId::Native,

4205

1

                    rate: 100,

4206

1

                    minimum_request_deadline_delay: 0,

4207

1

                    soft_minimum_deposit: 0,

4208

1

},

4209

1

                deposit: 101,

4210

1

                last_time_updated: 102,

4211

1

                request_nonce: 103,

4212

1

                pending_request: None,

4213

1

                opening_deposit: 104,

4214

1

4215

);

4216

1

})

4217

1

4218

4219

#[test]

4220

1

fn test_container_deregister_unassign_data_preserver() {

4221

1

    ExtBuilder::default()

4222

1

        .with_balances(vec![

4223

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4224

1

            (AccountId::from(BOB), 100_000 * UNIT),

4225

1

])

4226

1

        .build()

4227

1

        .execute_with(|| {

4228

            use pallet_data_preservers::{

4229

                AssignerParameterOf, NodeType, ParaIdsFilter, Profile, ProviderRequestOf,

4230

};

4231

4232

1

            let profile = Profile {

4233

1

                bootnode_url: Some(b"test".to_vec().try_into().unwrap()),

4234

1

                direct_rpc_urls: Default::default(),

4235

1

                proxy_rpc_urls: Default::default(),

4236

1

                para_ids: ParaIdsFilter::AnyParaId,

4237

1

                node_type: NodeType::Substrate,

4238

1

                additional_info: Default::default(),

4239

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

4240

1

};

4241

4242

1

            let para_id = ParaId::from(1002);

4243

1

            let profile_id = 0u64;

4244

4245

1

            assert_ok!(Registrar::register(

4246

1

                origin_of(ALICE.into()),

4247

1

                para_id,

4248

1

                empty_genesis_data(),

4249

1

                None

4250

));

4251

4252

1

            assert_ok!(DataPreservers::create_profile(

4253

1

                origin_of(BOB.into()),

4254

1

                profile.clone(),

4255

));

4256

4257

            // Start assignment

4258

1

            assert_ok!(DataPreservers::start_assignment(

4259

1

                origin_of(ALICE.into()),

4260

1

                profile_id,

4261

1

                para_id,

4262

1

                AssignerParameterOf::<Runtime>::Free

4263

));

4264

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&0u64));

4265

4266

            // Deregister from Registrar

4267

1

            assert_ok!(Registrar::deregister(root_origin(), para_id), ());

4268

4269

            // Check DataPreserver assignment has been cleared

4270

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).is_empty());

4271

1

});

4272

1

4273

4274

#[test]

4275

1

fn test_data_preserver_with_stream_payment() {

4276

1

    ExtBuilder::default()

4277

1

        .with_balances(vec![

4278

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4279

1

            (AccountId::from(BOB), 100_000 * UNIT),

4280

1

])

4281

1

        .build()

4282

1

        .execute_with(|| {

4283

            use pallet_data_preservers::{

4284

                AssignerParameterOf, NodeType, ParaIdsFilter, Profile, ProviderRequestOf,

4285

};

4286

4287

1

            let profile = Profile {

4288

1

                bootnode_url: Some(b"test".to_vec().try_into().unwrap()),

4289

1

                direct_rpc_urls: Default::default(),

4290

1

                proxy_rpc_urls: Default::default(),

4291

1

                para_ids: ParaIdsFilter::AnyParaId,

4292

1

                node_type: NodeType::Substrate,

4293

1

                additional_info: Default::default(),

4294

1

                assignment_request: ProviderRequestOf::<Runtime>::StreamPayment {

4295

1

                    config: StreamConfig {

4296

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

4297

1

                        asset_id: StreamPaymentAssetId::Native,

4298

1

                        rate: 42,

4299

1

                        minimum_request_deadline_delay: 0,

4300

1

                        soft_minimum_deposit: 0,

4301

1

},

4302

1

},

4303

1

};

4304

4305

1

            let para_id = ParaId::from(1002);

4306

1

            let profile_id = 0u64;

4307

4308

1

            assert_ok!(Registrar::register(

4309

1

                origin_of(ALICE.into()),

4310

1

                para_id,

4311

1

                empty_genesis_data(),

4312

1

                None

4313

));

4314

4315

1

            assert_ok!(DataPreservers::create_profile(

4316

1

                origin_of(BOB.into()),

4317

1

                profile.clone(),

4318

));

4319

4320

            // Start assignment

4321

1

            assert_ok!(DataPreservers::start_assignment(

4322

1

                origin_of(ALICE.into()),

4323

1

                profile_id,

4324

1

                para_id,

4325

1

                AssignerParameterOf::<Runtime>::StreamPayment {

4326

1

                    initial_deposit: 1_000

4327

1

4328

));

4329

1

            assert!(

4330

1

                pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&profile_id)

4331

);

4332

1

            let profile = pallet_data_preservers::Profiles::<Runtime>::get(profile_id)

4333

1

                .expect("profile to exists");

4334

1

            let (assigned_para_id, witness) = profile.assignment.expect("profile to be assigned");

4335

1

            assert_eq!(assigned_para_id, para_id);

4336

1

            assert_eq!(

4337

                witness,

4338

                tp_data_preservers_common::AssignmentWitness::StreamPayment { stream_id: 0 }

4339

);

4340

1

});

4341

1

4342

4343

#[test]

4344

1

fn test_data_preserver_kind_needs_to_match() {

4345

1

    ExtBuilder::default()

4346

1

        .with_balances(vec![

4347

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4348

1

            (AccountId::from(BOB), 100_000 * UNIT),

4349

1

])

4350

1

        .build()

4351

1

        .execute_with(|| {

4352

            use pallet_data_preservers::{

4353

                AssignerParameterOf, NodeType, ParaIdsFilter, Profile, ProviderRequestOf,

4354

};

4355

4356

1

            let profile = Profile {

4357

1

                bootnode_url: Some(b"test".to_vec().try_into().unwrap()),

4358

1

                direct_rpc_urls: Default::default(),

4359

1

                proxy_rpc_urls: Default::default(),

4360

1

                para_ids: ParaIdsFilter::AnyParaId,

4361

1

                node_type: NodeType::Substrate,

4362

1

                additional_info: Default::default(),

4363

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

4364

1

};

4365

4366

1

            let para_id = ParaId::from(1002);

4367

1

            let profile_id = 0u64;

4368

4369

1

            assert_ok!(Registrar::register(

4370

1

                origin_of(ALICE.into()),

4371

1

                para_id,

4372

1

                empty_genesis_data(),

4373

1

                None

4374

));

4375

4376

1

            assert_ok!(DataPreservers::create_profile(

4377

1

                origin_of(BOB.into()),

4378

1

                profile.clone(),

4379

));

4380

4381

            // Start assignment

4382

1

            assert_err!(

4383

1

                DataPreservers::start_assignment(

4384

1

                    origin_of(ALICE.into()),

4385

1

                    profile_id,

4386

1

                    para_id,

4387

1

                    AssignerParameterOf::<Runtime>::StreamPayment {

4388

1

                        initial_deposit: 1_000

4389

1

4390

),

4391

1

                pallet_data_preservers::Error::<Runtime>::AssignmentPaymentRequestParameterMismatch

4392

);

4393

1

});

4394

1

4395

4396

#[test]

4397

1

fn test_registrar_extrinsic_permissions() {

4398

1

    ExtBuilder::default()

4399

1

        .with_balances(vec![

4400

1

4401

1

                cumulus_primitives_core::relay_chain::AccountId::from(ALICE),

4402

1

                210_000 * UNIT,

4403

1

),

4404

1

4405

1

                cumulus_primitives_core::relay_chain::AccountId::from(BOB),

4406

1

                100_000 * UNIT,

4407

1

),

4408

1

])

4409

1

        .with_empty_parachains(vec![1001])

4410

1

        .build()

4411

1

        .execute_with(|| {

4412

1

            let para_id = ParaId::from(1001);

4413

4414

            // Pause container chain should fail if not para manager

4415

1

            assert_noop!(

4416

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

4417

1

                BadOrigin

4418

);

4419

4420

            // Set Bob as para manager

4421

1

            assert_ok!(Registrar::set_para_manager(

4422

1

                root_origin(),

4423

1

                para_id,

4424

1

                AccountId::from(BOB)

4425

));

4426

4427

            // Pause container chain should succeed if para manager

4428

1

            assert_ok!(

4429

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

4430

()

4431

);

4432

1

});

4433

1