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

        // set 1 collator per chain

2210

1

        .with_config(pallet_configuration::HostConfiguration {

2211

1

            max_collators: 100,

2212

1

            min_orchestrator_collators: 1,

2213

1

            max_orchestrator_collators: 1,

2214

1

            collators_per_container: 1,

2215

1

            ..Default::default()

2216

1

})

2217

1

        .with_empty_parachains(vec![1001, 1002])

2218

1

        .build()

2219

1

        .execute_with(|| {

2220

1

            run_to_block(2);

2221

2222

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

2223

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

2224

            // rewards.

2225

2226

            // wait for next session so that ALICE is elected

2227

1

            run_to_session(4u32);

2228

2229

            // Verify that all chains have collators

2230

1

            let collator_assignment = CollatorAssignment::collator_container_chain();

2231

            // 2 container chains total

2232

1

            assert_eq!(collator_assignment.container_chains.len(), 2);

2233

            // 1 collator on orchestrator

2234

1

            assert_eq!(collator_assignment.orchestrator_chain.len(), 1);

2235

            // 1 collator per container chain

2236

1

            assert!(collator_assignment

2237

1

                .container_chains

2238

1

                .values()

2239

2

                .all(|cs| cs.len() == 1));

2240

2241

1

            let account: AccountId = ALICE.into();

2242

1

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

2243

2244

1

            let summary = (0..100)

2245

1

                .find_map(|_| {

2246

1

                    let summary = run_block();

2247

1

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

2248

1

                        Some(summary)

2249

                    } else {

2250

                        None

2251

2252

1

})

2253

1

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

2254

2255

1

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

2256

2257

1

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

2258

            // rewards are shared between orchestrator and registered paras

2259

1

            let orchestrator_rewards = all_rewards / 3;

2260

1

            assert_eq!(

2261

                orchestrator_rewards,

2262

1

                balance_after - balance_before,

2263

                "alice should get the correct reward portion"

2264

);

2265

1

});

2266

1

2267

2268

#[test]

2269

1

fn test_reward_to_invulnerable_with_key_change() {

2270

1

    ExtBuilder::default()

2271

1

        .with_balances(vec![

2272

1

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

2273

1

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

2274

1

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

2275

1

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

2276

1

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

2277

1

])

2278

1

        .with_collators(vec![

2279

1

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

2280

1

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

2281

1

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

2282

1

])

2283

1

        // set 1 collator per chain

2284

1

        .with_config(pallet_configuration::HostConfiguration {

2285

1

            max_collators: 100,

2286

1

            min_orchestrator_collators: 1,

2287

1

            max_orchestrator_collators: 1,

2288

1

            collators_per_container: 1,

2289

1

            ..Default::default()

2290

1

})

2291

1

        .with_empty_parachains(vec![1001, 1002])

2292

1

        .build()

2293

1

        .execute_with(|| {

2294

1

            run_to_block(2);

2295

2296

1

            run_to_session(2u32);

2297

2298

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

2299

1

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

2300

1

            assert_ok!(Session::set_keys(

2301

1

                origin_of(ALICE.into()),

2302

1

                crate::SessionKeys {

2303

1

                    nimbus: alice_new_key,

2304

1

},

2305

1

                vec![]

2306

));

2307

2308

1

            run_to_session(4u32);

2309

2310

            // Verify that all chains have collators

2311

1

            let collator_assignment = CollatorAssignment::collator_container_chain();

2312

            // 2 container chains total

2313

1

            assert_eq!(collator_assignment.container_chains.len(), 2);

2314

            // 1 collator on orchestrator

2315

1

            assert_eq!(collator_assignment.orchestrator_chain.len(), 1);

2316

            // 1 collator per container chain

2317

1

            assert!(collator_assignment

2318

1

                .container_chains

2319

1

                .values()

2320

2

                .all(|cs| cs.len() == 1));

2321

2322

1

            let account: AccountId = ALICE.into();

2323

1

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

2324

2325

1

            let summary = run_block();

2326

1

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

2327

2328

1

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

2329

2330

1

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

2331

            // rewards are shared between orchestrator and registered paras

2332

1

            let orchestrator_rewards = all_rewards / 3;

2333

1

            assert_eq!(

2334

                orchestrator_rewards,

2335

1

                balance_after - balance_before,

2336

                "alice should get the correct reward portion"

2337

);

2338

1

});

2339

1

2340

2341

#[test]

2342

1

fn test_reward_chain_without_collators() {

2343

1

    ExtBuilder::default()

2344

1

        .with_balances(vec![

2345

1

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

2346

1

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

2347

1

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

2348

1

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

2349

1

])

2350

1

        .with_collators(vec![

2351

1

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

2352

1

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

2353

1

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

2354

1

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

2355

1

])

2356

1

        .with_empty_parachains(vec![1001, 1002])

2357

1

        .build()

2358

1

        .execute_with(|| {

2359

1

            run_to_block(2);

2360

1

            let account: AccountId = ALICE.into();

2361

1

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

2362

2363

1

            let summary = run_block();

2364

1

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

2365

2366

1

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

2367

2368

1

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

2369

1

            let alice_rewards = balance_after - balance_before;

2370

2371

1

            let assignment = CollatorAssignment::collator_container_chain();

2372

1

            assert_eq!(assignment.container_chains.len(), 2);

2373

1

            assert_eq!(

2374

1

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

2375

1

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

2376

);

2377

            // The other chain has 0 collators

2378

1

            assert_eq!(assignment.container_chains[&1002u32.into()], vec![]);

2379

2380

            // There are 2 registered chains but only 1 has collators. So we mint tokens for 2

2381

            // chains (orchestrator + 1 container). So Alice gets 1/2 instead of 1/3.

2382

1

            assert_eq!(

2383

                alice_rewards,

2384

1

                all_rewards / 2,

2385

                "alice should get half of the rewards when there is 1 container chain with collators",

2386

);

2387

1

});

2388

1

2389

2390

#[test]

2391

1

fn test_reward_no_container_chains_still_has_inflation() {

2392

1

    ExtBuilder::default()

2393

1

        .with_balances(vec![

2394

1

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

2395

1

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

2396

1

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

2397

1

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

2398

1

])

2399

1

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

2400

1

        .with_config(pallet_configuration::HostConfiguration {

2401

1

            max_collators: 100,

2402

1

            min_orchestrator_collators: 1,

2403

1

            max_orchestrator_collators: 1,

2404

1

            collators_per_container: 1,

2405

1

            ..Default::default()

2406

1

})

2407

1

        .with_empty_parachains(vec![1001, 1002])

2408

1

        .build()

2409

1

        .execute_with(|| {

2410

1

            run_to_block(2);

2411

1

            let account: AccountId = ALICE.into();

2412

1

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

2413

2414

1

            let summary = run_block();

2415

1

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

2416

2417

1

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

2418

2419

1

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

2420

1

            let alice_rewards = balance_after - balance_before;

2421

2422

            // All container chains have 0 collators

2423

1

            let assignment = CollatorAssignment::collator_container_chain();

2424

            // There are 2 chains registered

2425

1

            assert_eq!(assignment.container_chains.len(), 2);

2426

            // But they don't have collators

2427

2

            assert!(assignment.container_chains.values().all(|cs| cs.len() == 0));

2428

2429

            // But we always reward orchestrator chain, so there is always inflation minted

2430

            // and the 100% goes to Alice

2431

1

            assert_eq!(

2432

                alice_rewards, all_rewards,

2433

                "alice should get the full reward when there are no container chains with collators",

2434

);

2435

1

});

2436

1

2437

2438

#[test]

2439

1

fn test_can_buy_credits_before_registering_para() {

2440

1

    ExtBuilder::default()

2441

1

        .with_balances(vec![

2442

1

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

2443

1

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

2444

1

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

2445

1

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

2446

1

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

2447

1

])

2448

1

        .with_collators(vec![

2449

1

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

2450

1

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

2451

1

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

2452

1

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

2453

1

])

2454

1

        .build()

2455

1

        .execute_with(|| {

2456

1

            run_to_block(2);

2457

2458

            // Try to buy the maximum amount of credits

2459

1

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

2460

1

            assert_ok!(ServicesPayment::purchase_credits(

2461

1

                origin_of(ALICE.into()),

2462

1

                1001.into(),

2463

1

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

2464

));

2465

1

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

2466

2467

            // Now parachain tank should have this amount

2468

1

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

2469

1

                .data

2470

1

                .free;

2471

2472

1

            assert_eq!(

2473

                balance_tank,

2474

1

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

2475

);

2476

2477

1

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

2478

1

            assert_eq!(balance_before - balance_after, expected_cost);

2479

1

});

2480

1

2481

2482

#[test]

2483

1

fn test_cannot_mark_valid_para_with_no_bootnodes() {

2484

1

    ExtBuilder::default()

2485

1

        .with_balances(vec![

2486

1

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

2487

1

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

2488

1

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

2489

1

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

2490

1

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

2491

1

])

2492

1

        .with_collators(vec![

2493

1

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

2494

1

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

2495

1

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

2496

1

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

2497

1

])

2498

1

        .build()

2499

1

        .execute_with(|| {

2500

1

            run_to_block(2);

2501

1

            assert_ok!(Registrar::register(

2502

1

                origin_of(ALICE.into()),

2503

1

                1001.into(),

2504

1

                empty_genesis_data(),

2505

1

                None

2506

));

2507

1

            assert_noop!(

2508

1

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

2509

1

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

2510

);

2511

1

});

2512

1

2513

2514

#[test]

2515

1

fn test_can_buy_credits_before_registering_para_and_receive_free_credits() {

2516

1

    ExtBuilder::default()

2517

1

        .with_balances(vec![

2518

1

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

2519

1

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

2520

1

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

2521

1

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

2522

1

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

2523

1

])

2524

1

        .with_collators(vec![

2525

1

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

2526

1

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

2527

1

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

2528

1

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

2529

1

])

2530

1

        .build()

2531

1

        .execute_with(|| {

2532

1

            run_to_block(2);

2533

2534

            // Try to buy (FreeBlockProductionCredits - 1) credits

2535

1

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

2536

1

            assert_ok!(ServicesPayment::purchase_credits(

2537

1

                origin_of(ALICE.into()),

2538

1

                1001.into(),

2539

1

                block_credits_to_required_balance(

2540

1

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

2541

1

                    1001.into()

2542

2543

));

2544

1

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

2545

2546

            // Now parachain tank should have this amount

2547

1

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

2548

1

                .data

2549

1

                .free;

2550

2551

1

            assert_eq!(

2552

                balance_tank,

2553

1

                block_credits_to_required_balance(

2554

1

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

2555

1

                    1001.into()

2556

2557

);

2558

2559

1

            let expected_cost = block_credits_to_required_balance(

2560

1

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

2561

1

                1001.into(),

2562

);

2563

1

            assert_eq!(balance_before - balance_after, expected_cost);

2564

2565

            // Now register para

2566

1

            assert_ok!(Registrar::register(

2567

1

                origin_of(ALICE.into()),

2568

1

                1001.into(),

2569

1

                empty_genesis_data(),

2570

1

                None

2571

));

2572

1

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

2573

1

            assert_ok!(Registrar::mark_valid_for_collating(

2574

1

                root_origin(),

2575

1

                1001.into()

2576

));

2577

2578

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

2579

1

            let credits =

2580

1

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

2581

1

                    .unwrap_or_default();

2582

1

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

2583

1

});

2584

1

2585

2586

#[test]

2587

1

fn test_deregister_and_register_again_does_not_give_free_credits() {

2588

1

    ExtBuilder::default()

2589

1

        .with_balances(vec![

2590

1

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

2591

1

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

2592

1

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

2593

1

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

2594

1

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

2595

1

])

2596

1

        .with_collators(vec![

2597

1

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

2598

1

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

2599

1

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

2600

1

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

2601

1

])

2602

1

        .build()

2603

1

        .execute_with(|| {

2604

1

            run_to_block(2);

2605

2606

            // Register

2607

1

            assert_ok!(Registrar::register(

2608

1

                origin_of(ALICE.into()),

2609

1

                1001.into(),

2610

1

                empty_genesis_data(),

2611

1

                None

2612

            ),);

2613

1

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

2614

1

            assert_ok!(Registrar::mark_valid_for_collating(

2615

1

                root_origin(),

2616

1

                1001.into()

2617

            ),);

2618

            // We received free credits

2619

1

            let credits =

2620

1

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

2621

1

                    .unwrap_or_default();

2622

1

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

2623

            // Deregister after 1 session

2624

1

            run_to_session(1);

2625

1

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

2626

2627

1

            run_to_session(3);

2628

1

            let credits_before_2nd_register =

2629

1

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

2630

1

                    .unwrap_or_default();

2631

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

2632

1

            assert_ne!(

2633

                credits_before_2nd_register,

2634

1

                crate::FreeBlockProductionCredits::get()

2635

);

2636

            // Register again

2637

1

            assert_ok!(Registrar::register(

2638

1

                origin_of(ALICE.into()),

2639

1

                1001.into(),

2640

1

                empty_genesis_data(),

2641

1

                None

2642

            ),);

2643

1

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

2644

1

            assert_ok!(Registrar::mark_valid_for_collating(

2645

1

                root_origin(),

2646

1

                1001.into()

2647

            ),);

2648

            // No more free credits

2649

1

            let credits =

2650

1

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

2651

1

                    .unwrap_or_default();

2652

1

            assert_eq!(credits, credits_before_2nd_register);

2653

1

});

2654

1

2655

2656

#[test]

2657

1

fn test_register_parathread_not_allowed() {

2658

1

    ExtBuilder::default()

2659

1

        .with_balances(vec![

2660

1

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

2661

1

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

2662

1

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

2663

1

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

2664

1

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

2665

1

])

2666

1

        .with_collators(vec![

2667

1

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

2668

1

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

2669

1

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

2670

1

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

2671

1

])

2672

1

        .build()

2673

1

        .execute_with(|| {

2674

1

            run_to_block(2);

2675

2676

1

            assert_noop!(

2677

1

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

2678

1

                    para_id: 3001.into(),

2679

1

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

2680

1

                    genesis_data: empty_genesis_data(),

2681

1

                    head_data: None

2682

1

})

2683

1

                .dispatch(

2684

1

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

2685

                        ALICE

2686

))

2687

),

2688

1

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

2689

);

2690

1

});

2691

1

2692

2693

#[test]

2694

1

fn test_register_parathread_genesis() {

2695

1

    let parathread_params = tp_traits::ParathreadParams {

2696

1

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

2697

1

};

2698

1

    ExtBuilder::default()

2699

1

        .with_balances(vec![

2700

1

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

2701

1

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

2702

1

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

2703

1

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

2704

1

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

2705

1

])

2706

1

        .with_collators(vec![

2707

1

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

2708

1

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

2709

1

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

2710

1

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

2711

1

])

2712

1

        .with_para_ids(vec![ParaRegistrationParams {

2713

1

            para_id: 3001,

2714

1

            genesis_data: empty_genesis_data(),

2715

1

            block_production_credits: u32::MAX,

2716

1

            collator_assignment_credits: u32::MAX,

2717

1

            parathread_params: Some(parathread_params.clone()),

2718

1

}])

2719

1

        .build()

2720

1

        .execute_with(|| {

2721

1

            run_to_block(2);

2722

2723

1

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

2724

1

            assert_eq!(

2725

1

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

2726

1

                Some(parathread_params)

2727

);

2728

2729

1

            let assignment = CollatorAssignment::collator_container_chain();

2730

1

            assert_eq!(

2731

1

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

2732

1

                vec![CHARLIE.into()]

2733

);

2734

1

});

2735

1

2736

2737

#[test]

2738

1

fn test_ed_plus_block_credit_session_purchase_works() {

2739

1

    ExtBuilder::default()

2740

1

        .with_balances(vec![

2741

1

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

2742

1

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

2743

1

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

2744

1

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

2745

1

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

2746

1

])

2747

1

        .with_collators(vec![

2748

1

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

2749

1

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

2750

1

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

2751

1

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

2752

1

])

2753

1

        .build()

2754

1

        .execute_with(|| {

2755

1

            run_to_block(2);

2756

            // Assert current slot gets updated

2757

1

            assert_eq!(current_slot(), 1u64);

2758

1

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

2759

2760

            // Alice and Bob collate in our chain

2761

1

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

2762

1

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

2763

2764

1

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

2765

2766

1

            assert_ok!(Registrar::register(

2767

1

                origin_of(ALICE.into()),

2768

1

                1001.into(),

2769

1

                empty_genesis_data(),

2770

1

                None

2771

));

2772

1

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

2773

1

            assert_ok!(Registrar::mark_valid_for_collating(

2774

1

                root_origin(),

2775

1

                1001.into()

2776

));

2777

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

2778

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2779

1

                root_origin(),

2780

1

                1001.into(),

2781

2782

));

2783

1

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

2784

1

                + crate::EXISTENTIAL_DEPOSIT;

2785

2786

            // Fill the tank

2787

1

            assert_ok!(ServicesPayment::purchase_credits(

2788

1

                origin_of(ALICE.into()),

2789

1

                1001.into(),

2790

1

                credits_1001

2791

));

2792

2793

            // Assignment should happen after 2 sessions

2794

1

            run_to_session(1u32);

2795

1

            let assignment = CollatorAssignment::collator_container_chain();

2796

1

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

2797

1

            run_to_session(2u32);

2798

            // Charlie and Dave should be assigned to para 1001

2799

1

            let assignment = CollatorAssignment::collator_container_chain();

2800

1

            assert_eq!(

2801

1

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

2802

1

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

2803

);

2804

2805

            // Simulate block inclusion from container chain 1001

2806

1

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

2807

1

            let slot: u64 = 5;

2808

1

            let s = ParaHeaderSproofBuilderItem {

2809

1

                para_id: 1001.into(),

2810

1

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

2811

1

                    parent_hash: Default::default(),

2812

1

                    number: 1,

2813

1

                    state_root: Default::default(),

2814

1

                    extrinsics_root: Default::default(),

2815

1

                    digest: sp_runtime::generic::Digest {

2816

1

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

2817

1

},

2818

1

}),

2819

1

};

2820

2821

1

            sproof.items.push(s);

2822

1

            set_author_noting_inherent_data(sproof);

2823

2824

1

            run_block();

2825

2826

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

2827

1

            run_to_session(3u32);

2828

            // Nobody should be assigned to para 1001

2829

1

            let assignment = CollatorAssignment::collator_container_chain();

2830

1

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

2831

1

});

2832

1

2833

2834

#[test]

2835

1

fn test_ed_plus_block_credit_session_minus_1_purchase_fails() {

2836

1

    ExtBuilder::default()

2837

1

        .with_balances(vec![

2838

1

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

2839

1

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

2840

1

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

2841

1

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

2842

1

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

2843

1

])

2844

1

        .with_collators(vec![

2845

1

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

2846

1

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

2847

1

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

2848

1

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

2849

1

])

2850

1

        .build()

2851

1

        .execute_with(|| {

2852

1

            run_to_block(2);

2853

            // Assert current slot gets updated

2854

1

            assert_eq!(current_slot(), 1u64);

2855

1

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

2856

2857

            // Alice and Bob collate in our chain

2858

1

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

2859

1

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

2860

2861

1

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

2862

2863

1

            assert_ok!(Registrar::register(

2864

1

                origin_of(ALICE.into()),

2865

1

                1001.into(),

2866

1

                empty_genesis_data(),

2867

1

                None

2868

));

2869

1

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

2870

1

            assert_ok!(Registrar::mark_valid_for_collating(

2871

1

                root_origin(),

2872

1

                1001.into()

2873

));

2874

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

2875

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2876

1

                root_origin(),

2877

1

                1001.into(),

2878

2879

));

2880

1

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

2881

1

                + crate::EXISTENTIAL_DEPOSIT

2882

1

                - 1;

2883

2884

            // Fill the tank

2885

1

            assert_ok!(ServicesPayment::purchase_credits(

2886

1

                origin_of(ALICE.into()),

2887

1

                1001.into(),

2888

1

                credits_1001

2889

));

2890

2891

            // Assignment should happen after 2 sessions

2892

1

            run_to_session(1u32);

2893

1

            let assignment = CollatorAssignment::collator_container_chain();

2894

1

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

2895

1

            run_to_session(2u32);

2896

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

2897

1

            let assignment = CollatorAssignment::collator_container_chain();

2898

1

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

2899

1

});

2900

1

2901

2902

#[test]

2903

1

fn test_reassignment_ed_plus_two_block_credit_session_purchase_works() {

2904

1

    ExtBuilder::default()

2905

1

        .with_balances(vec![

2906

1

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

2907

1

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

2908

1

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

2909

1

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

2910

1

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

2911

1

])

2912

1

        .with_collators(vec![

2913

1

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

2914

1

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

2915

1

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

2916

1

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

2917

1

])

2918

1

        .build()

2919

1

        .execute_with(|| {

2920

1

            run_to_block(2);

2921

            // Assert current slot gets updated

2922

1

            assert_eq!(current_slot(), 1u64);

2923

1

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

2924

2925

            // Alice and Bob collate in our chain

2926

1

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

2927

1

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

2928

2929

1

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

2930

2931

1

            assert_ok!(Registrar::register(

2932

1

                origin_of(ALICE.into()),

2933

1

                1001.into(),

2934

1

                empty_genesis_data(),

2935

1

                None

2936

));

2937

1

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

2938

1

            assert_ok!(Registrar::mark_valid_for_collating(

2939

1

                root_origin(),

2940

1

                1001.into()

2941

));

2942

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

2943

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2944

1

                root_origin(),

2945

1

                1001.into(),

2946

2947

));

2948

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

2949

1

            let credits_1001 =

2950

1

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

2951

1

                    + crate::EXISTENTIAL_DEPOSIT;

2952

2953

            // Fill the tank

2954

1

            assert_ok!(ServicesPayment::purchase_credits(

2955

1

                origin_of(ALICE.into()),

2956

1

                1001.into(),

2957

1

                credits_1001

2958

));

2959

2960

            // Assignment should happen after 2 sessions

2961

1

            run_to_session(1u32);

2962

1

            let assignment = CollatorAssignment::collator_container_chain();

2963

1

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

2964

2965

1

            run_to_session(2u32);

2966

            // Charlie and Dave should be assigned to para 1001

2967

1

            let assignment = CollatorAssignment::collator_container_chain();

2968

1

            assert_eq!(

2969

1

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

2970

1

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

2971

);

2972

2973

            // Simulate block inclusion from container chain 1001

2974

1

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

2975

1

            let slot: u64 = 5;

2976

1

            let s = ParaHeaderSproofBuilderItem {

2977

1

                para_id: 1001.into(),

2978

1

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

2979

1

                    parent_hash: Default::default(),

2980

1

                    number: 1,

2981

1

                    state_root: Default::default(),

2982

1

                    extrinsics_root: Default::default(),

2983

1

                    digest: sp_runtime::generic::Digest {

2984

1

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

2985

1

},

2986

1

}),

2987

1

};

2988

2989

1

            sproof.items.push(s);

2990

1

            set_author_noting_inherent_data(sproof);

2991

2992

1

            run_block();

2993

2994

            // Session 3 should still be assigned

2995

1

            run_to_session(3u32);

2996

            // Charlie and Dave should be assigned to para 1001

2997

1

            let assignment = CollatorAssignment::collator_container_chain();

2998

1

            assert_eq!(

2999

1

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

3000

1

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

3001

);

3002

3003

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

3004

1

            run_to_session(4u32);

3005

            // Nobody should be assigned to para 1001

3006

1

            let assignment = CollatorAssignment::collator_container_chain();

3007

1

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

3008

1

});

3009

1

3010

3011

#[test]

3012

1

fn test_reassignment_ed_plus_two_block_credit_session_minus_1_purchase_fails() {

3013

1

    ExtBuilder::default()

3014

1

        .with_balances(vec![

3015

1

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

3016

1

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

3017

1

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

3018

1

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

3019

1

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

3020

1

])

3021

1

        .with_collators(vec![

3022

1

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

3023

1

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

3024

1

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

3025

1

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

3026

1

])

3027

1

        .build()

3028

1

        .execute_with(|| {

3029

1

            run_to_block(2);

3030

            // Assert current slot gets updated

3031

1

            assert_eq!(current_slot(), 1u64);

3032

1

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

3033

3034

            // Alice and Bob collate in our chain

3035

1

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

3036

1

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

3037

3038

1

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

3039

3040

1

            assert_ok!(Registrar::register(

3041

1

                origin_of(ALICE.into()),

3042

1

                1001.into(),

3043

1

                empty_genesis_data(),

3044

1

                None

3045

));

3046

1

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

3047

1

            assert_ok!(Registrar::mark_valid_for_collating(

3048

1

                root_origin(),

3049

1

                1001.into()

3050

));

3051

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

3052

1

            assert_ok!(ServicesPayment::set_block_production_credits(

3053

1

                root_origin(),

3054

1

                1001.into(),

3055

3056

));

3057

1

            let credits_1001 =

3058

1

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

3059

1

                    + crate::EXISTENTIAL_DEPOSIT

3060

1

                    - 1;

3061

3062

            // Fill the tank

3063

1

            assert_ok!(ServicesPayment::purchase_credits(

3064

1

                origin_of(ALICE.into()),

3065

1

                1001.into(),

3066

1

                credits_1001

3067

));

3068

3069

            // Assignment should happen after 2 sessions

3070

1

            run_to_session(1u32);

3071

1

            let assignment = CollatorAssignment::collator_container_chain();

3072

1

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

3073

3074

1

            run_to_session(2u32);

3075

            // Charlie and Dave should be assigned to para 1001

3076

1

            let assignment = CollatorAssignment::collator_container_chain();

3077

1

            assert_eq!(

3078

1

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

3079

1

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

3080

);

3081

3082

            // Simulate block inclusion from container chain 1001

3083

1

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

3084

1

            let slot: u64 = 5;

3085

1

            let s = ParaHeaderSproofBuilderItem {

3086

1

                para_id: 1001.into(),

3087

1

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

3088

1

                    parent_hash: Default::default(),

3089

1

                    number: 1,

3090

1

                    state_root: Default::default(),

3091

1

                    extrinsics_root: Default::default(),

3092

1

                    digest: sp_runtime::generic::Digest {

3093

1

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

3094

1

},

3095

1

}),

3096

1

};

3097

3098

1

            sproof.items.push(s);

3099

1

            set_author_noting_inherent_data(sproof);

3100

3101

1

            run_block();

3102

3103

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

3104

1

            run_to_session(3u32);

3105

            // Nobody should be assigned to para 1001

3106

1

            let assignment = CollatorAssignment::collator_container_chain();

3107

1

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

3108

1

});

3109

1

3110

3111

#[test]

3112

1

fn test_credits_with_purchase_can_be_combined() {

3113

1

    ExtBuilder::default()

3114

1

        .with_balances(vec![

3115

1

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

3116

1

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

3117

1

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

3118

1

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

3119

1

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

3120

1

])

3121

1

        .with_collators(vec![

3122

1

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

3123

1

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

3124

1

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

3125

1

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

3126

1

])

3127

1

        .build()

3128

1

        .execute_with(|| {

3129

1

            run_to_block(2);

3130

            // Assert current slot gets updated

3131

1

            assert_eq!(current_slot(), 1u64);

3132

1

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

3133

3134

            // Alice and Bob collate in our chain

3135

1

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

3136

1

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

3137

3138

1

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

3139

3140

1

            assert_ok!(Registrar::register(

3141

1

                origin_of(ALICE.into()),

3142

1

                1001.into(),

3143

1

                empty_genesis_data(),

3144

1

                None

3145

));

3146

1

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

3147

1

            assert_ok!(Registrar::mark_valid_for_collating(

3148

1

                root_origin(),

3149

1

                1001.into()

3150

));

3151

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

3152

1

            assert_ok!(ServicesPayment::set_block_production_credits(

3153

1

                root_origin(),

3154

1

                1001.into(),

3155

1

                crate::Period::get()

3156

));

3157

1

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

3158

1

                + crate::EXISTENTIAL_DEPOSIT;

3159

3160

            // Fill the tank

3161

1

            assert_ok!(ServicesPayment::purchase_credits(

3162

1

                origin_of(ALICE.into()),

3163

1

                1001.into(),

3164

1

                credits_1001

3165

));

3166

3167

            // Assignment should happen after 2 sessions

3168

1

            run_to_session(1u32);

3169

1

            let assignment = CollatorAssignment::collator_container_chain();

3170

1

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

3171

1

            run_to_session(2u32);

3172

            // Charlie and Dave should be assigned to para 1001

3173

1

            let assignment = CollatorAssignment::collator_container_chain();

3174

1

            assert_eq!(

3175

1

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

3176

1

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

3177

);

3178

1

});

3179

1

3180

#[test]

3181

1

fn stream_payment_works() {

3182

1

    ExtBuilder::default()

3183

1

        .with_balances(vec![

3184

1

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

3185

1

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

3186

1

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

3187

1

])

3188

1

        .with_collators(vec![

3189

1

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

3190

1

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

3191

1

])

3192

1

        .build()

3193

1

        .execute_with(|| {

3194

            use pallet_stream_payment::{ChangeKind, StreamConfig};

3195

3196

1

            assert_ok!(StreamPayment::open_stream(

3197

1

                origin_of(ALICE.into()),

3198

1

                BOB.into(),

3199

1

                StreamConfig {

3200

1

                    rate: 2 * UNIT,

3201

1

                    asset_id: StreamPaymentAssetId::Native,

3202

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

3203

1

                    minimum_request_deadline_delay: 0,

3204

1

                    soft_minimum_deposit: 0,

3205

1

},

3206

1

                1_000 * UNIT,

3207

));

3208

3209

1

            run_block();

3210

3211

1

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

3212

1

            assert_eq!(

3213

1

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

3214

                100_000 * UNIT + 2 * UNIT

3215

);

3216

3217

1

            assert_ok!(StreamPayment::request_change(

3218

1

                origin_of(ALICE.into()),

3219

0,

3220

1

                ChangeKind::Suggestion,

3221

1

                StreamConfig {

3222

1

                    rate: 1 * UNIT,

3223

1

                    asset_id: StreamPaymentAssetId::Native,

3224

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

3225

1

                    minimum_request_deadline_delay: 0,

3226

1

                    soft_minimum_deposit: 0,

3227

1

},

3228

1

                None,

3229

));

3230

3231

1

            assert_ok!(StreamPayment::accept_requested_change(

3232

1

                origin_of(BOB.into()),

3233

0,

3234

                1, // nonce

3235

1

                None,

3236

));

3237

3238

1

            run_block();

3239

3240

1

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

3241

3242

1

            assert_eq!(

3243

1

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

3244

                100_000 * UNIT + 3 * UNIT

3245

);

3246

1

            assert_eq!(

3247

1

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

3248

                100_000 * UNIT - 3 * UNIT

3249

);

3250

1

});

3251

1

3252

3253

#[test]

3254

1

fn test_ed_plus_collator_assignment_session_purchase_works() {

3255

1

    ExtBuilder::default()

3256

1

        .with_balances(vec![

3257

1

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

3258

1

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

3259

1

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

3260

1

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

3261

1

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

3262

1

])

3263

1

        .with_collators(vec![

3264

1

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

3265

1

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

3266

1

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

3267

1

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

3268

1

])

3269

1

        .build()

3270

1

        .execute_with(|| {

3271

1

            run_to_block(2);

3272

            // Assert current slot gets updated

3273

1

            assert_eq!(current_slot(), 1u64);

3274

1

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

3275

3276

            // Alice and Bob collate in our chain

3277

1

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

3278

1

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

3279

3280

1

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

3281

3282

1

            assert_ok!(Registrar::register(

3283

1

                origin_of(ALICE.into()),

3284

1

                1001.into(),

3285

1

                empty_genesis_data(),

3286

1

                None

3287

));

3288

1

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

3289

1

            assert_ok!(Registrar::mark_valid_for_collating(

3290

1

                root_origin(),

3291

1

                1001.into()

3292

));

3293

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

3294

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3295

1

                root_origin(),

3296

1

                1001.into(),

3297

3298

));

3299

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3300

1

                + crate::EXISTENTIAL_DEPOSIT;

3301

3302

            // Fill the tank

3303

1

            assert_ok!(ServicesPayment::purchase_credits(

3304

1

                origin_of(ALICE.into()),

3305

1

                1001.into(),

3306

1

                credits_1001

3307

));

3308

3309

            // Assignment should happen after 2 sessions

3310

1

            run_to_session(1u32);

3311

1

            let assignment = CollatorAssignment::collator_container_chain();

3312

1

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

3313

1

            run_to_session(2u32);

3314

            // Charlie and Dave should be assigned to para 1001

3315

1

            let assignment = CollatorAssignment::collator_container_chain();

3316

1

            assert_eq!(

3317

1

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

3318

1

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

3319

);

3320

3321

            // Simulate block inclusion from container chain 1001

3322

1

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

3323

1

            let slot: u64 = 5;

3324

1

            let s = ParaHeaderSproofBuilderItem {

3325

1

                para_id: 1001.into(),

3326

1

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

3327

1

                    parent_hash: Default::default(),

3328

1

                    number: 1,

3329

1

                    state_root: Default::default(),

3330

1

                    extrinsics_root: Default::default(),

3331

1

                    digest: sp_runtime::generic::Digest {

3332

1

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

3333

1

},

3334

1

}),

3335

1

};

3336

1

            sproof.items.push(s);

3337

1

            set_author_noting_inherent_data(sproof);

3338

3339

1

            run_block();

3340

3341

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

3342

1

            run_to_session(4u32);

3343

            // Nobody should be assigned to para 1001

3344

1

            let assignment = CollatorAssignment::collator_container_chain();

3345

1

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

3346

1

});

3347

1

3348

3349

#[test]

3350

1

fn test_ed_plus_collator_assignment_credit_session_minus_1_purchase_fails() {

3351

1

    ExtBuilder::default()

3352

1

        .with_balances(vec![

3353

1

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

3354

1

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

3355

1

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

3356

1

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

3357

1

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

3358

1

])

3359

1

        .with_collators(vec![

3360

1

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

3361

1

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

3362

1

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

3363

1

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

3364

1

])

3365

1

        .build()

3366

1

        .execute_with(|| {

3367

1

            run_to_block(2);

3368

            // Assert current slot gets updated

3369

1

            assert_eq!(current_slot(), 1u64);

3370

1

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

3371

3372

            // Alice and Bob collate in our chain

3373

1

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

3374

1

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

3375

3376

1

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

3377

3378

1

            assert_ok!(Registrar::register(

3379

1

                origin_of(ALICE.into()),

3380

1

                1001.into(),

3381

1

                empty_genesis_data(),

3382

1

                None

3383

));

3384

1

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

3385

1

            assert_ok!(Registrar::mark_valid_for_collating(

3386

1

                root_origin(),

3387

1

                1001.into()

3388

));

3389

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

3390

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3391

1

                root_origin(),

3392

1

                1001.into(),

3393

3394

));

3395

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3396

1

                + crate::EXISTENTIAL_DEPOSIT

3397

1

                - 1;

3398

3399

            // Fill the tank

3400

1

            assert_ok!(ServicesPayment::purchase_credits(

3401

1

                origin_of(ALICE.into()),

3402

1

                1001.into(),

3403

1

                credits_1001

3404

));

3405

3406

            // Assignment should happen after 2 sessions

3407

1

            run_to_session(1u32);

3408

1

            let assignment = CollatorAssignment::collator_container_chain();

3409

1

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

3410

1

            run_to_session(2u32);

3411

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

3412

1

            let assignment = CollatorAssignment::collator_container_chain();

3413

1

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

3414

1

});

3415

1

3416

3417

#[test]

3418

1

fn test_collator_assignment_credits_with_purchase_can_be_combined() {

3419

1

    ExtBuilder::default()

3420

1

        .with_balances(vec![

3421

1

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

3422

1

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

3423

1

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

3424

1

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

3425

1

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

3426

1

])

3427

1

        .with_collators(vec![

3428

1

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

3429

1

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

3430

1

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

3431

1

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

3432

1

])

3433

1

        .build()

3434

1

        .execute_with(|| {

3435

1

            run_to_block(2);

3436

            // Assert current slot gets updated

3437

1

            assert_eq!(current_slot(), 1u64);

3438

1

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

3439

3440

            // Alice and Bob collate in our chain

3441

1

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

3442

1

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

3443

3444

1

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

3445

3446

1

            assert_ok!(Registrar::register(

3447

1

                origin_of(ALICE.into()),

3448

1

                1001.into(),

3449

1

                empty_genesis_data(),

3450

1

                None

3451

));

3452

1

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

3453

1

            assert_ok!(Registrar::mark_valid_for_collating(

3454

1

                root_origin(),

3455

1

                1001.into()

3456

));

3457

3458

            // We assign one session to free credits

3459

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3460

1

                root_origin(),

3461

1

                1001.into(),

3462

3463

));

3464

            // We buy another session through the tank

3465

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3466

1

                + crate::EXISTENTIAL_DEPOSIT;

3467

3468

            // Fill the tank

3469

1

            assert_ok!(ServicesPayment::purchase_credits(

3470

1

                origin_of(ALICE.into()),

3471

1

                1001.into(),

3472

1

                credits_1001

3473

));

3474

3475

            // Assignment should happen after 2 sessions

3476

1

            run_to_session(1u32);

3477

1

            let assignment = CollatorAssignment::collator_container_chain();

3478

1

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

3479

1

            run_to_session(2u32);

3480

            // Charlie and Dave should be assigned to para 1001

3481

1

            let assignment = CollatorAssignment::collator_container_chain();

3482

1

            assert_eq!(

3483

1

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

3484

1

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

3485

);

3486

1

});

3487

1

3488

3489

#[test]

3490

1

fn test_block_credits_and_collator_assignation_credits_through_tank() {

3491

1

    ExtBuilder::default()

3492

1

        .with_balances(vec![

3493

1

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

3494

1

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

3495

1

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

3496

1

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

3497

1

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

3498

1

])

3499

1

        .with_collators(vec![

3500

1

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

3501

1

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

3502

1

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

3503

1

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

3504

1

])

3505

1

        .build()

3506

1

        .execute_with(|| {

3507

1

            run_to_block(2);

3508

            // Assert current slot gets updated

3509

1

            assert_eq!(current_slot(), 1u64);

3510

1

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

3511

3512

            // Alice and Bob collate in our chain

3513

1

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

3514

1

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

3515

3516

1

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

3517

3518

1

            assert_ok!(Registrar::register(

3519

1

                origin_of(ALICE.into()),

3520

1

                1001.into(),

3521

1

                empty_genesis_data(),

3522

1

                None

3523

));

3524

1

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

3525

1

            assert_ok!(Registrar::mark_valid_for_collating(

3526

1

                root_origin(),

3527

1

                1001.into()

3528

));

3529

3530

            // We make all free credits 0

3531

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3532

1

                root_origin(),

3533

1

                1001.into(),

3534

3535

));

3536

1

            assert_ok!(ServicesPayment::set_block_production_credits(

3537

1

                root_origin(),

3538

1

                1001.into(),

3539

3540

));

3541

3542

            // We buy 2 sessions through tank

3543

1

            let collator_assignation_credits =

3544

1

                collator_assignment_credits_to_required_balance(2, 1001.into());

3545

1

            let block_production_credits =

3546

1

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

3547

3548

            // Fill the tank

3549

1

            assert_ok!(ServicesPayment::purchase_credits(

3550

1

                origin_of(ALICE.into()),

3551

1

                1001.into(),

3552

1

                collator_assignation_credits

3553

1

                    + block_production_credits

3554

1

                    + crate::EXISTENTIAL_DEPOSIT

3555

));

3556

3557

            // Assignment should happen after 2 sessions

3558

1

            run_to_session(1u32);

3559

1

            let assignment = CollatorAssignment::collator_container_chain();

3560

1

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

3561

1

            run_to_session(2u32);

3562

            // Charlie and Dave should be assigned to para 1001

3563

1

            let assignment = CollatorAssignment::collator_container_chain();

3564

1

            assert_eq!(

3565

1

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

3566

1

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

3567

);

3568

3569

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

3570

1

            run_to_session(4u32);

3571

            // Nobody should be assigned to para 1001

3572

1

            let assignment = CollatorAssignment::collator_container_chain();

3573

1

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

3574

1

});

3575

1

3576

3577

#[test]

3578

1

fn test_migration_services_collator_assignment_payment() {

3579

1

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

3580

        // Register a new parachain with no credits

3581

1

        assert_ok!(Registrar::register(

3582

1

            origin_of(ALICE.into()),

3583

1

            1001.into(),

3584

1

            empty_genesis_data(),

3585

1

            None

3586

));

3587

1

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

3588

1

        assert_ok!(Registrar::mark_valid_for_collating(

3589

1

            root_origin(),

3590

1

            1001.into()

3591

));

3592

        // Register another parachain with no credits, do not mark this as valid for collation

3593

1

        assert_ok!(Registrar::register(

3594

1

            origin_of(ALICE.into()),

3595

1

            1002.into(),

3596

1

            empty_genesis_data(),

3597

1

            None

3598

));

3599

1

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

3600

1

        assert_ok!(Registrar::mark_valid_for_collating(

3601

1

            root_origin(),

3602

1

            1002.into()

3603

));

3604

3605

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

3606

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

3607

1

            root_origin(),

3608

1

            1001.into(),

3609

3610

));

3611

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

3612

1

            root_origin(),

3613

1

            1002.into(),

3614

3615

));

3616

3617

1

        let credits_1001 =

3618

1

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

3619

1

                .unwrap_or_default();

3620

1

        assert_eq!(credits_1001, 0);

3621

1

        let credits_1002 =

3622

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

3623

1

                .unwrap_or_default();

3624

1

        assert_eq!(credits_1002, 0);

3625

3626

        // Apply migration

3627

1

        let migration =

3628

1

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

3629

1

        migration.migrate(Default::default());

3630

3631

        // Both parachains have been given credits

3632

1

        let credits_1001 =

3633

1

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

3634

1

                .unwrap_or_default();

3635

1

        assert_eq!(credits_1001, crate::FreeCollatorAssignmentCredits::get());

3636

1

        let credits_1002 =

3637

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

3638

1

                .unwrap_or_default();

3639

1

        assert_eq!(credits_1002, crate::FreeCollatorAssignmentCredits::get());

3640

1

});

3641

1

3642

3643

#[test]

3644

1

fn test_max_collators_uses_pending_value() {

3645

    // Start with max_collators = 100, and collators_per_container = 2

3646

    // Set max_collators = 2, and collators_per_container = 3

3647

    // It should be impossible to have more than 2 collators per container at any point in time

3648

1

    ExtBuilder::default()

3649

1

        .with_balances(vec![

3650

1

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

3651

1

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

3652

1

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

3653

1

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

3654

1

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

3655

1

])

3656

1

        .with_collators(vec![

3657

1

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

3658

1

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

3659

1

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

3660

1

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

3661

1

])

3662

1

        .with_empty_parachains(vec![1001])

3663

1

        .with_config(pallet_configuration::HostConfiguration {

3664

1

            max_collators: 100,

3665

1

            min_orchestrator_collators: 1,

3666

1

            max_orchestrator_collators: 1,

3667

1

            collators_per_container: 2,

3668

1

            full_rotation_period: 24,

3669

1

            ..Default::default()

3670

1

})

3671

1

        .build()

3672

1

        .execute_with(|| {

3673

1

            run_to_block(2);

3674

3675

            // Initial assignment: 1 collator in orchestrator chain and 2 collators in container 1001

3676

1

            let assignment = CollatorAssignment::collator_container_chain();

3677

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 2);

3678

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

3679

3680

1

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

3681

1

            assert_ok!(Configuration::set_collators_per_container(root_origin(), 3));

3682

3683

            // Check invariant for all intermediate assignments. We set collators_per_container = 3

3684

            // but we also set max_collators = 2, so no collators will be assigned to container

3685

            // chains after the change is applied.

3686

5

            for session in 1..=4 {

3687

4

                run_to_session(session);

3688

3689

4

                let assignment = CollatorAssignment::collator_container_chain();

3690

4

                assert!(

3691

4

                    assignment.container_chains[&1001u32.into()].len() <= 2,

3692

                    "session {}: {} collators assigned to container chain 1001",

3693

                    session,

3694

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

3695

);

3696

3697

3698

            // Final assignment: because max_collators = 2, there are only 2 collators, one in

3699

            // orchestrator chain, and the other one idle

3700

1

            let assignment = CollatorAssignment::collator_container_chain();

3701

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 0);

3702

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

3703

1

});

3704

1

3705

3706

#[test]

3707

1

fn test_slow_adjusting_multiplier_changes_in_response_to_consumed_weight() {

3708

1

    ExtBuilder::default()

3709

1

        .with_collators(vec![

3710

1

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

3711

1

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

3712

1

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

3713

1

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

3714

1

])

3715

1

        .build()

3716

1

        .execute_with(|| {

3717

1

            end_block();

3718

            // If the block is full, the multiplier increases

3719

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

3720

1

            start_block();

3721

1

            let max_block_weights = crate::RuntimeBlockWeights::get();

3722

1

            frame_support::storage::unhashed::put(

3723

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

3724

3

                &ConsumedWeight::new(|class| {

3725

3

                    max_block_weights

3726

3

                        .get(class)

3727

3

                        .max_total

3728

3

                        .unwrap_or(Weight::MAX)

3729

3

}),

3730

);

3731

1

            end_block();

3732

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

3733

1

            assert!(current_multiplier > before_multiplier);

3734

3735

            // If the block is empty, the multiplier decreases

3736

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

3737

1

            start_block();

3738

1

            frame_support::storage::unhashed::put(

3739

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

3740

3

                &ConsumedWeight::new(|_class| Weight::zero()),

3741

);

3742

1

            end_block();

3743

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

3744

1

            assert!(current_multiplier < before_multiplier);

3745

1

});

3746

1

3747

3748

#[test]

3749

1

fn test_collator_assignment_tip_dont_have_priority_on_congestion() {

3750

1

    ExtBuilder::default()

3751

1

        .with_balances(vec![

3752

1

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

3753

1

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

3754

1

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

3755

1

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

3756

1

])

3757

1

        .with_collators(vec![

3758

1

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

3759

1

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

3760

1

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

3761

1

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

3762

1

])

3763

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3764

1

        .build()

3765

1

        .execute_with(|| {

3766

1

            let para_id = 1003u32;

3767

1

            let tank_funds = 100 * UNIT;

3768

1

            let max_tip = 1 * UNIT;

3769

3770

1

            assert_eq!(

3771

1

                CollatorAssignment::collator_container_chain().container_chains[&1003u32.into()]

3772

1

                    .len(),

3773

3774

);

3775

3776

            // Send funds to tank

3777

1

            assert_ok!(ServicesPayment::purchase_credits(

3778

1

                origin_of(ALICE.into()),

3779

1

                para_id.into(),

3780

1

                tank_funds,

3781

));

3782

3783

            // Set tip for 1003

3784

1

            assert_ok!(ServicesPayment::set_max_tip(

3785

1

                root_origin(),

3786

1

                para_id.into(),

3787

1

                Some(max_tip),

3788

));

3789

3790

1

            run_to_session(2);

3791

1

            assert_eq!(

3792

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

3793

1

                    .len(),

3794

0,

3795

);

3796

1

});

3797

1

3798

3799

#[test]

3800

1

fn test_collator_assignment_tip_charged_on_congestion_assigned_before() {

3801

1

    ExtBuilder::default()

3802

1

        // We need enough collators for the orchestrator + 2 container chains to be assigned 2 collators

3803

1

        // each AND being not enough collators for all chains to have congestion. Since orchestrator takes 2

3804

1

        // colators we need 6 collators in total to have 1001 and 1002 assigned but not 1003 due to congestion.

3805

1

//

3806

1

        // 1002 is already assigned without tip, and we ensure that 1002 tipping moves it first AND

3807

1

        // tip is payed. We cannot test with 1003 as it was not assigned before, AND already assigned

3808

1

        // chains are prioritized.

3809

1

        .with_balances(vec![

3810

1

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

3811

1

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

3812

1

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

3813

1

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

3814

1

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

3815

1

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

3816

1

])

3817

1

        .with_collators(vec![

3818

1

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

3819

1

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

3820

1

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

3821

1

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

3822

1

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

3823

1

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

3824

1

])

3825

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3826

1

        .build()

3827

1

        .execute_with(|| {

3828

1

            let tank_funds = 100 * UNIT;

3829

1

            let max_tip = 1 * UNIT;

3830

1

            let para_id = 1002u32;

3831

3832

            // Send funds to tank

3833

1

            assert_ok!(ServicesPayment::purchase_credits(

3834

1

                origin_of(ALICE.into()),

3835

1

                para_id.into(),

3836

1

                tank_funds,

3837

));

3838

3839

            // Set tip for para_id

3840

1

            assert_ok!(ServicesPayment::set_max_tip(

3841

1

                root_origin(),

3842

1

                para_id.into(),

3843

1

                Some(max_tip),

3844

));

3845

3846

1

            run_to_session(1);

3847

1

            assert_eq!(

3848

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id.into())),

3849

1

                tank_funds - max_tip,

3850

);

3851

1

});

3852

1

3853

3854

#[test]

3855

1

fn test_collator_assignment_tip_not_assigned_on_insufficient_balance() {

3856

1

    ExtBuilder::default()

3857

1

        .with_balances(vec![

3858

1

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

3859

1

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

3860

1

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

3861

1

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

3862

1

])

3863

1

        .with_collators(vec![

3864

1

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

3865

1

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

3866

1

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

3867

1

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

3868

1

])

3869

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3870

1

        .build()

3871

1

        .execute_with(|| {

3872

1

            let tank_funds = 1 * UNIT;

3873

1

            let max_tip = 1 * UNIT;

3874

1

            let para_id = 1003u32;

3875

3876

            // Send insufficient funds to tank for tip for 2 sessions

3877

1

            assert_ok!(ServicesPayment::purchase_credits(

3878

1

                origin_of(ALICE.into()),

3879

1

                para_id.into(),

3880

1

                tank_funds,

3881

));

3882

3883

            // Set tip for para_id

3884

1

            assert_ok!(ServicesPayment::set_max_tip(

3885

1

                root_origin(),

3886

1

                para_id.into(),

3887

1

                Some(max_tip),

3888

));

3889

3890

1

            run_to_session(1);

3891

1

            assert_eq!(

3892

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

3893

1

                    .len(),

3894

3895

);

3896

1

});

3897

1

3898

3899

#[test]

3900

1

fn test_collator_assignment_tip_only_charge_willing_paras() {

3901

1

    ExtBuilder::default()

3902

1

        .with_balances(vec![

3903

1

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

3904

1

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

3905

1

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

3906

1

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

3907

1

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

3908

1

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

3909

1

])

3910

1

        .with_collators(vec![

3911

1

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

3912

1

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

3913

1

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

3914

1

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

3915

1

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

3916

1

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

3917

1

])

3918

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3919

1

        .build()

3920

1

        .execute_with(|| {

3921

1

            let tank_funds = 100 * UNIT;

3922

1

            let max_tip = 1 * UNIT;

3923

1

            let para_id_with_tip = 1002u32;

3924

1

            let para_id_without_tip = 1001u32;

3925

3926

            // Send funds to tank to both paras

3927

1

            assert_ok!(ServicesPayment::purchase_credits(

3928

1

                origin_of(ALICE.into()),

3929

1

                para_id_with_tip.into(),

3930

1

                tank_funds,

3931

));

3932

1

            assert_ok!(ServicesPayment::purchase_credits(

3933

1

                origin_of(ALICE.into()),

3934

1

                para_id_without_tip.into(),

3935

1

                tank_funds,

3936

));

3937

3938

            // Only set tip for 1002

3939

1

            assert_ok!(ServicesPayment::set_max_tip(

3940

1

                root_origin(),

3941

1

                para_id_with_tip.into(),

3942

1

                Some(max_tip),

3943

));

3944

3945

1

            run_to_session(2);

3946

3947

1

            let assignment = CollatorAssignment::collator_container_chain().container_chains;

3948

3949

            // 2 out of the 3 paras should have collators assigned, with one paying tip to get

3950

            // prioritized, and the other selected at random that should not be charged any tips

3951

1

            assert_eq!(assignment[&para_id_with_tip.into()].len(), 2);

3952

1

            assert_eq!(

3953

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_with_tip.into())),

3954

1

                tank_funds - max_tip * 2,

3955

);

3956

3957

1

            assert_eq!(assignment[&para_id_without_tip.into()].len(), 2);

3958

1

            assert_eq!(

3959

1

                Balances::usable_balance(ServicesPayment::parachain_tank(

3960

1

                    para_id_without_tip.into()

3961

)),

3962

                tank_funds,

3963

);

3964

1

});

3965

1

3966

3967

#[test]

3968

1

fn test_collator_assignment_tip_withdraw_min_tip() {

3969

1

    ExtBuilder::default()

3970

1

        .with_balances(vec![

3971

1

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

3972

1

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

3973

1

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

3974

1

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

3975

1

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

3976

1

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

3977

1

])

3978

1

        .with_collators(vec![

3979

1

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

3980

1

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

3981

1

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

3982

1

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

3983

1

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

3984

1

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

3985

1

])

3986

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3987

1

        .build()

3988

1

        .execute_with(|| {

3989

1

            let tank_funds = 100 * UNIT;

3990

1

            let max_tip_1001 = 3 * UNIT;

3991

1

            let max_tip_1002 = 2 * UNIT;

3992

1

            let para_id_1001 = 1001u32;

3993

1

            let para_id_1002 = 1002u32;

3994

3995

            // Send funds to tank to both paras

3996

1

            assert_ok!(ServicesPayment::purchase_credits(

3997

1

                origin_of(ALICE.into()),

3998

1

                para_id_1001.into(),

3999

1

                tank_funds,

4000

));

4001

1

            assert_ok!(ServicesPayment::purchase_credits(

4002

1

                origin_of(ALICE.into()),

4003

1

                para_id_1002.into(),

4004

1

                tank_funds,

4005

));

4006

4007

            // Set tips

4008

1

            assert_ok!(ServicesPayment::set_max_tip(

4009

1

                root_origin(),

4010

1

                para_id_1001.into(),

4011

1

                Some(max_tip_1001),

4012

));

4013

1

            assert_ok!(ServicesPayment::set_max_tip(

4014

1

                root_origin(),

4015

1

                para_id_1002.into(),

4016

1

                Some(max_tip_1002),

4017

));

4018

4019

1

            run_to_session(2);

4020

4021

1

            assert_eq!(

4022

1

                CollatorAssignment::collator_container_chain().container_chains

4023

1

                    [&para_id_1001.into()]

4024

1

                    .len(),

4025

4026

);

4027

1

            assert_eq!(

4028

1

                CollatorAssignment::collator_container_chain().container_chains

4029

1

                    [&para_id_1002.into()]

4030

1

                    .len(),

4031

4032

);

4033

4034

            // Should have withdrawn the lowest tip from both paras

4035

1

            assert_eq!(

4036

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1001.into())),

4037

1

                tank_funds - max_tip_1002 * 2,

4038

);

4039

4040

1

            assert_eq!(

4041

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1002.into())),

4042

1

                tank_funds - max_tip_1002 * 2,

4043

);

4044

1

});

4045

1

4046

4047

#[test]

4048

1

fn test_migration_data_preservers_profile_content() {

4049

1

    ExtBuilder::default()

4050

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

4051

1

        .build()

4052

1

        .execute_with(|| {

4053

            use frame_support::{migration::put_storage_value, Blake2_128Concat, StorageHasher};

4054

            use pallet_data_preservers::{

4055

                migrations::{OldProfile, OldRegisteredProfile, ProfileMode},

4056

                NodeType, ParaIdsFilter, Profile, RegisteredProfile,

4057

};

4058

            use sp_runtime::traits::Zero;

4059

            use tanssi_runtime_common::migrations::DataPreserversProfileContentMigration;

4060

            use tp_stream_payment_common::AssetId;

4061

4062

1

            let bootnode_profile = OldRegisteredProfile::<Runtime> {

4063

1

                account: ALICE.into(),

4064

1

                deposit: 42u128,

4065

1

                assignment: None,

4066

1

                profile: OldProfile {

4067

1

                    url: b"alice".to_vec().try_into().unwrap(),

4068

1

                    para_ids: ParaIdsFilter::AnyParaId,

4069

1

                    assignment_request: tp_data_preservers_common::ProviderRequest::Free,

4070

1

                    mode: ProfileMode::Bootnode,

4071

1

},

4072

1

};

4073

4074

1

            let substrate_rpc_profile = OldRegisteredProfile::<Runtime> {

4075

1

                account: BOB.into(),

4076

1

                deposit: 43u128,

4077

1

                assignment: Some((

4078

1

                    ParaId::from(1042),

4079

1

                    tp_data_preservers_common::AssignmentWitness::Free,

4080

1

)),

4081

1

4082

1

                profile: OldProfile {

4083

1

                    url: b"bob".to_vec().try_into().unwrap(),

4084

1

                    para_ids: ParaIdsFilter::AnyParaId,

4085

1

                    assignment_request: tp_data_preservers_common::ProviderRequest::Free,

4086

1

                    mode: ProfileMode::Rpc {

4087

1

                        supports_ethereum_rpcs: false,

4088

1

},

4089

1

},

4090

1

};

4091

4092

1

            let stream_config = pallet_stream_payment::StreamConfig {

4093

1

                time_unit: tp_stream_payment_common::TimeUnit::BlockNumber,

4094

1

                asset_id: AssetId::Native,

4095

1

                rate: 100u128,

4096

1

                minimum_request_deadline_delay: Zero::zero(),

4097

1

                soft_minimum_deposit: Zero::zero(),

4098

1

};

4099

1

            let frontier_rpc_profile = OldRegisteredProfile::<Runtime> {

4100

1

                account: CHARLIE.into(),

4101

1

                deposit: 44u128,

4102

1

                assignment: Some((

4103

1

                    ParaId::from(1043),

4104

1

                    tp_data_preservers_common::AssignmentWitness::StreamPayment { stream_id: 200 },

4105

1

)),

4106

1

                profile: OldProfile {

4107

1

                    url: b"charlie".to_vec().try_into().unwrap(),

4108

1

                    para_ids: ParaIdsFilter::AnyParaId,

4109

1

                    assignment_request: tp_data_preservers_common::ProviderRequest::StreamPayment {

4110

1

                        config: stream_config,

4111

1

},

4112

1

                    mode: ProfileMode::Rpc {

4113

1

                        supports_ethereum_rpcs: true,

4114

1

},

4115

1

},

4116

1

};

4117

4118

1

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

4119

1

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

4120

4121

1

            put_storage_value(

4122

1

                pallet_prefix,

4123

1

                storage_item_prefix,

4124

1

                &Blake2_128Concat::hash(&0u64.encode()),

4125

1

                bootnode_profile,

4126

);

4127

1

            put_storage_value(

4128

1

                pallet_prefix,

4129

1

                storage_item_prefix,

4130

1

                &Blake2_128Concat::hash(&1u64.encode()),

4131

1

                substrate_rpc_profile,

4132

);

4133

1

            put_storage_value(

4134

1

                pallet_prefix,

4135

1

                storage_item_prefix,

4136

1

                &Blake2_128Concat::hash(&2u64.encode()),

4137

1

                frontier_rpc_profile,

4138

);

4139

4140

1

            let migration = DataPreserversProfileContentMigration::<Runtime>(Default::default());

4141

1

            migration.migrate(Default::default());

4142

4143

1

            assert_eq!(

4144

1

                pallet_data_preservers::Profiles::<Runtime>::get(0),

4145

1

                Some(RegisteredProfile {

4146

1

                    account: ALICE.into(),

4147

1

                    deposit: 42u128,

4148

1

                    assignment: None,

4149

1

                    profile: Profile {

4150

1

                        para_ids: ParaIdsFilter::AnyParaId,

4151

1

                        assignment_request: tp_data_preservers_common::ProviderRequest::Free,

4152

1

                        node_type: NodeType::Substrate,

4153

1

                        additional_info: Default::default(),

4154

1

                        direct_rpc_urls: Default::default(),

4155

1

                        proxy_rpc_urls: Default::default(),

4156

1

                        bootnode_url: Some(b"alice".to_vec().try_into().unwrap())

4157

1

4158

1

})

4159

);

4160

4161

1

            assert_eq!(

4162

1

                pallet_data_preservers::Profiles::<Runtime>::get(1),

4163

1

                Some(RegisteredProfile {

4164

1

                    account: BOB.into(),

4165

1

                    deposit: 43u128,

4166

1

                    assignment: Some((

4167

1

                        ParaId::from(1042),

4168

1

                        tp_data_preservers_common::AssignmentWitness::Free

4169

1

)),

4170

1

                    profile: Profile {

4171

1

                        para_ids: ParaIdsFilter::AnyParaId,

4172

1

                        assignment_request: tp_data_preservers_common::ProviderRequest::Free,

4173

1

                        node_type: NodeType::Substrate,

4174

1

                        additional_info: Default::default(),

4175

1

                        direct_rpc_urls: {

4176

1

                            let url = b"bob".to_vec().try_into().unwrap();

4177

1

                            let urls = vec![url].try_into().unwrap();

4178

1

                            urls

4179

1

},

4180

1

                        proxy_rpc_urls: Default::default(),

4181

1

                        bootnode_url: None

4182

1

4183

1

})

4184

);

4185

4186

1

            assert_eq!(

4187

1

                pallet_data_preservers::Profiles::<Runtime>::get(2),

4188

1

                Some(RegisteredProfile {

4189

1

                    account: CHARLIE.into(),

4190

1

                    deposit: 44u128,

4191

1

                    assignment: Some((

4192

1

                        ParaId::from(1043),

4193

1

                        tp_data_preservers_common::AssignmentWitness::StreamPayment {

4194

1

                            stream_id: 200,

4195

1

4196

1

)),

4197

1

                    profile: Profile {

4198

1

                        para_ids: ParaIdsFilter::AnyParaId,

4199

1

                        assignment_request:

4200

1

                            tp_data_preservers_common::ProviderRequest::StreamPayment {

4201

1

                                config: stream_config

4202

1

},

4203

1

                        node_type: NodeType::Frontier,

4204

1

                        additional_info: Default::default(),

4205

1

                        direct_rpc_urls: {

4206

1

                            let url = b"charlie".to_vec().try_into().unwrap();

4207

1

                            let urls = vec![url].try_into().unwrap();

4208

1

                            urls

4209

1

},

4210

1

                        proxy_rpc_urls: Default::default(),

4211

1

                        bootnode_url: None

4212

1

4213

1

})

4214

);

4215

1

})

4216

1

4217

4218

#[test]

4219

1

fn test_migration_registrar_reserves_to_hold() {

4220

1

    ExtBuilder::default()

4221

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

4222

1

        .build()

4223

1

        .execute_with(|| {

4224

            use {

4225

                frame_support::traits::{fungible::InspectHold, ReservableCurrency},

4226

                pallet_registrar::DepositInfo,

4227

                tanssi_runtime_common::migrations::RegistrarReserveToHoldMigration,

4228

};

4229

4230

1

            let deposit: Balance = 100 * UNIT;

4231

1

            let account: AccountId = DAVE.into();

4232

4233

1

            assert_ok!(Balances::reserve(&account, deposit));

4234

4235

1

            pallet_registrar::RegistrarDeposit::<Runtime>::insert(

4236

1

                ParaId::from(1001),

4237

1

                DepositInfo {

4238

1

                    creator: account.clone(),

4239

1

                    deposit,

4240

1

},

4241

);

4242

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

4243

            // Apply migration

4244

1

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

4245

1

            migration.migrate(Default::default());

4246

4247

            // Holds also count as reserved balance, so the total reserved amount

4248

            // shouldn't change after the migration

4249

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

4250

4251

1

            assert_eq!(

4252

1

                Balances::balance_on_hold(

4253

1

                    &pallet_registrar::HoldReason::RegistrarDeposit.into(),

4254

1

                    &account

4255

),

4256

                deposit

4257

);

4258

1

})

4259

1

4260

4261

#[test]

4262

1

fn test_migration_stream_payment_config_new_fields() {

4263

1

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

4264

        use pallet_stream_payment::{

4265

            migrations::{OldChangeRequest, OldStream, OldStreamConfig},

4266

            ChangeKind, ChangeRequest, DepositChange, Party, Stream, StreamConfig,

4267

};

4268

        use tanssi_runtime_common::migrations::MigrateStreamPaymentNewConfigFields;

4269

4270

1

        frame_support::storage::unhashed::put(

4271

1

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

4272

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

4273

1

                source: ALICE.into(),

4274

1

                target: BOB.into(),

4275

1

                config: OldStreamConfig {

4276

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4277

1

                    asset_id: StreamPaymentAssetId::Native,

4278

1

                    rate: 41,

4279

1

},

4280

1

                deposit: 42,

4281

1

                last_time_updated: 43,

4282

1

                request_nonce: 44,

4283

1

                pending_request: Some(OldChangeRequest {

4284

1

                    requester: Party::Source,

4285

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

4286

1

                    new_config: OldStreamConfig {

4287

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

4288

1

                        asset_id: StreamPaymentAssetId::Native,

4289

1

                        rate: 46,

4290

1

},

4291

1

                    deposit_change: Some(DepositChange::Absolute(47)),

4292

1

}),

4293

1

                opening_deposit: 48,

4294

1

},

4295

);

4296

4297

1

        frame_support::storage::unhashed::put(

4298

1

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

4299

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

4300

1

                source: CHARLIE.into(),

4301

1

                target: ALICE.into(),

4302

1

                config: OldStreamConfig {

4303

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4304

1

                    asset_id: StreamPaymentAssetId::Native,

4305

1

                    rate: 100,

4306

1

},

4307

1

                deposit: 101,

4308

1

                last_time_updated: 102,

4309

1

                request_nonce: 103,

4310

1

                pending_request: None,

4311

1

                opening_deposit: 104,

4312

1

},

4313

);

4314

4315

1

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

4316

1

        migration.migrate(Default::default());

4317

4318

1

        assert_eq!(

4319

1

            pallet_stream_payment::Streams::<Runtime>::get(0).unwrap(),

4320

1

            Stream {

4321

1

                source: ALICE.into(),

4322

1

                target: BOB.into(),

4323

1

                config: StreamConfig {

4324

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4325

1

                    asset_id: StreamPaymentAssetId::Native,

4326

1

                    rate: 41,

4327

1

                    minimum_request_deadline_delay: 0,

4328

1

                    soft_minimum_deposit: 0,

4329

1

},

4330

1

                deposit: 42,

4331

1

                last_time_updated: 43,

4332

1

                request_nonce: 44,

4333

1

                pending_request: Some(ChangeRequest {

4334

1

                    requester: Party::Source,

4335

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

4336

1

                    new_config: StreamConfig {

4337

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

4338

1

                        asset_id: StreamPaymentAssetId::Native,

4339

1

                        rate: 46,

4340

1

                        minimum_request_deadline_delay: 0,

4341

1

                        soft_minimum_deposit: 0,

4342

1

},

4343

1

                    deposit_change: Some(DepositChange::Absolute(47)),

4344

1

}),

4345

1

                opening_deposit: 48,

4346

1

4347

);

4348

4349

1

        assert_eq!(

4350

1

            pallet_stream_payment::Streams::<Runtime>::get(1).unwrap(),

4351

1

            Stream {

4352

1

                source: CHARLIE.into(),

4353

1

                target: ALICE.into(),

4354

1

                config: StreamConfig {

4355

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4356

1

                    asset_id: StreamPaymentAssetId::Native,

4357

1

                    rate: 100,

4358

1

                    minimum_request_deadline_delay: 0,

4359

1

                    soft_minimum_deposit: 0,

4360

1

},

4361

1

                deposit: 101,

4362

1

                last_time_updated: 102,

4363

1

                request_nonce: 103,

4364

1

                pending_request: None,

4365

1

                opening_deposit: 104,

4366

1

4367

);

4368

1

})

4369

1

4370

4371

#[test]

4372

1

fn test_container_deregister_unassign_data_preserver() {

4373

1

    ExtBuilder::default()

4374

1

        .with_balances(vec![

4375

1

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

4376

1

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

4377

1

])

4378

1

        .build()

4379

1

        .execute_with(|| {

4380

            use pallet_data_preservers::{

4381

                AssignerParameterOf, NodeType, ParaIdsFilter, Profile, ProviderRequestOf,

4382

};

4383

4384

1

            let profile = Profile {

4385

1

                bootnode_url: Some(b"test".to_vec().try_into().unwrap()),

4386

1

                direct_rpc_urls: Default::default(),

4387

1

                proxy_rpc_urls: Default::default(),

4388

1

                para_ids: ParaIdsFilter::AnyParaId,

4389

1

                node_type: NodeType::Substrate,

4390

1

                additional_info: Default::default(),

4391

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

4392

1

};

4393

4394

1

            let para_id = ParaId::from(1002);

4395

1

            let profile_id = 0u64;

4396

4397

1

            assert_ok!(Registrar::register(

4398

1

                origin_of(ALICE.into()),

4399

1

                para_id,

4400

1

                empty_genesis_data(),

4401

1

                None

4402

));

4403

4404

1

            assert_ok!(DataPreservers::create_profile(

4405

1

                origin_of(BOB.into()),

4406

1

                profile.clone(),

4407

));

4408

4409

            // Start assignment

4410

1

            assert_ok!(DataPreservers::start_assignment(

4411

1

                origin_of(ALICE.into()),

4412

1

                profile_id,

4413

1

                para_id,

4414

1

                AssignerParameterOf::<Runtime>::Free

4415

));

4416

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&0u64));

4417

4418

            // Deregister from Registrar

4419

1

            assert_ok!(Registrar::deregister(root_origin(), para_id), ());

4420

4421

            // Check DataPreserver assignment has been cleared

4422

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).is_empty());

4423

1

});

4424

1

4425

4426

#[test]

4427

1

fn test_data_preserver_with_stream_payment() {

4428

1

    ExtBuilder::default()

4429

1

        .with_balances(vec![

4430

1

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

4431

1

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

4432

1

])

4433

1

        .build()

4434

1

        .execute_with(|| {

4435

            use pallet_data_preservers::{

4436

                AssignerParameterOf, NodeType, ParaIdsFilter, Profile, ProviderRequestOf,

4437

};

4438

4439

1

            let profile = Profile {

4440

1

                bootnode_url: Some(b"test".to_vec().try_into().unwrap()),

4441

1

                direct_rpc_urls: Default::default(),

4442

1

                proxy_rpc_urls: Default::default(),

4443

1

                para_ids: ParaIdsFilter::AnyParaId,

4444

1

                node_type: NodeType::Substrate,

4445

1

                additional_info: Default::default(),

4446

1

                assignment_request: ProviderRequestOf::<Runtime>::StreamPayment {

4447

1

                    config: StreamConfig {

4448

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

4449

1

                        asset_id: StreamPaymentAssetId::Native,

4450

1

                        rate: 42,

4451

1

                        minimum_request_deadline_delay: 0,

4452

1

                        soft_minimum_deposit: 0,

4453

1

},

4454

1

},

4455

1

};

4456

4457

1

            let para_id = ParaId::from(1002);

4458

1

            let profile_id = 0u64;

4459

4460

1

            assert_ok!(Registrar::register(

4461

1

                origin_of(ALICE.into()),

4462

1

                para_id,

4463

1

                empty_genesis_data(),

4464

1

                None

4465

));

4466

4467

1

            assert_ok!(DataPreservers::create_profile(

4468

1

                origin_of(BOB.into()),

4469

1

                profile.clone(),

4470

));

4471

4472

            // Start assignment

4473

1

            assert_ok!(DataPreservers::start_assignment(

4474

1

                origin_of(ALICE.into()),

4475

1

                profile_id,

4476

1

                para_id,

4477

1

                AssignerParameterOf::<Runtime>::StreamPayment {

4478

1

                    initial_deposit: 1_000

4479

1

4480

));

4481

1

            assert!(

4482

1

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

4483

);

4484

1

            let profile = pallet_data_preservers::Profiles::<Runtime>::get(profile_id)

4485

1

                .expect("profile to exists");

4486

1

            let (assigned_para_id, witness) = profile.assignment.expect("profile to be assigned");

4487

1

            assert_eq!(assigned_para_id, para_id);

4488

1

            assert_eq!(

4489

                witness,

4490

                tp_data_preservers_common::AssignmentWitness::StreamPayment { stream_id: 0 }

4491

);

4492

1

});

4493

1

4494

4495

#[test]

4496

1

fn test_data_preserver_kind_needs_to_match() {

4497

1

    ExtBuilder::default()

4498

1

        .with_balances(vec![

4499

1

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

4500

1

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

4501

1

])

4502

1

        .build()

4503

1

        .execute_with(|| {

4504

            use pallet_data_preservers::{

4505

                AssignerParameterOf, NodeType, ParaIdsFilter, Profile, ProviderRequestOf,

4506

};

4507

4508

1

            let profile = Profile {

4509

1

                bootnode_url: Some(b"test".to_vec().try_into().unwrap()),

4510

1

                direct_rpc_urls: Default::default(),

4511

1

                proxy_rpc_urls: Default::default(),

4512

1

                para_ids: ParaIdsFilter::AnyParaId,

4513

1

                node_type: NodeType::Substrate,

4514

1

                additional_info: Default::default(),

4515

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

4516

1

};

4517

4518

1

            let para_id = ParaId::from(1002);

4519

1

            let profile_id = 0u64;

4520

4521

1

            assert_ok!(Registrar::register(

4522

1

                origin_of(ALICE.into()),

4523

1

                para_id,

4524

1

                empty_genesis_data(),

4525

1

                None

4526

));

4527

4528

1

            assert_ok!(DataPreservers::create_profile(

4529

1

                origin_of(BOB.into()),

4530

1

                profile.clone(),

4531

));

4532

4533

            // Start assignment

4534

1

            assert_err!(

4535

1

                DataPreservers::start_assignment(

4536

1

                    origin_of(ALICE.into()),

4537

1

                    profile_id,

4538

1

                    para_id,

4539

1

                    AssignerParameterOf::<Runtime>::StreamPayment {

4540

1

                        initial_deposit: 1_000

4541

1

4542

),

4543

1

                pallet_data_preservers::Error::<Runtime>::AssignmentPaymentRequestParameterMismatch

4544

);

4545

1

});

4546

1

4547

4548

#[test]

4549

1

fn test_registrar_extrinsic_permissions() {

4550

1

    ExtBuilder::default()

4551

1

        .with_balances(vec![

4552

1

4553

1

                cumulus_primitives_core::relay_chain::AccountId::from(ALICE),

4554

1

                210_000 * UNIT,

4555

1

),

4556

1

4557

1

                cumulus_primitives_core::relay_chain::AccountId::from(BOB),

4558

1

                100_000 * UNIT,

4559

1

),

4560

1

])

4561

1

        .with_empty_parachains(vec![1001])

4562

1

        .build()

4563

1

        .execute_with(|| {

4564

1

            let para_id = ParaId::from(1001);

4565

4566

            // Pause container chain should fail if not para manager

4567

1

            assert_noop!(

4568

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

4569

1

                BadOrigin

4570

);

4571

4572

            // Set Bob as para manager

4573

1

            assert_ok!(Registrar::set_para_manager(

4574

1

                root_origin(),

4575

1

                para_id,

4576

1

                AccountId::from(BOB)

4577

));

4578

4579

            // Pause container chain should succeed if para manager

4580

1

            assert_ok!(

4581

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

4582

()

4583

);

4584

1

});

4585

1