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

    cumulus_primitives_core::{ParaId, Weight},

22

    dp_consensus::runtime_decl_for_tanssi_authority_assignment_api::TanssiAuthorityAssignmentApiV1,

23

    dp_core::well_known_keys,

24

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

25

    frame_system::ConsumedWeight,

26

    nimbus_primitives::NIMBUS_KEY_ID,

27

    pallet_author_noting_runtime_api::runtime_decl_for_author_noting_api::AuthorNotingApi,

28

    pallet_collator_assignment_runtime_api::runtime_decl_for_collator_assignment_api::CollatorAssignmentApi,

29

    pallet_migrations::Migration,

30

    pallet_registrar_runtime_api::{

31

        runtime_decl_for_registrar_api::RegistrarApi, ContainerChainGenesisData,

32

},

33

    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

    sp_std::vec,

42

    tanssi_runtime_common::migrations::MigrateServicesPaymentAddCollatorAssignmentCredits,

43

    test_relay_sproof_builder::{HeaderAs, ParaHeaderSproofBuilder, ParaHeaderSproofBuilderItem},

44

    tp_stream_payment_common::{

45

        AssetId as StreamPaymentAssetId, TimeUnit as StreamPaymentTimeUnit,

46

},

47

    tp_traits::{ContainerChainBlockInfo, SlotFrequency},

48

};

49

50

20

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

51

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

52

53

20

    let profile = Profile {

54

20

        url:

55

20

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

56

20

                .to_vec()

57

20

                .try_into()

58

20

                .expect("to fit in BoundedVec"),

59

20

        para_ids: ParaIdsFilter::AnyParaId,

60

20

        mode: ProfileMode::Bootnode,

61

20

        assignment_request: tp_data_preservers_common::ProviderRequest::Free,

62

20

};

63

20

64

20

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

65

20

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

66

20

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

67

20

        .expect("profile create to succeed");

68

20

69

20

    DataPreservers::start_assignment(

70

20

        para_manager,

71

20

        profile_id,

72

20

        para_id,

73

20

        tp_data_preservers_common::AssignerExtra::Free,

74

20

75

20

    .expect("assignement to work");

76

20

77

20

    assert!(

78

20

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

79

        "profile should be correctly assigned"

80

);

81

20

82

83

#[test]

84

1

fn genesis_balances() {

85

1

    ExtBuilder::default()

86

1

        .with_balances(vec![

87

1

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

88

1

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

89

1

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

90

1

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

91

1

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

92

1

])

93

1

        .with_collators(vec![

94

1

            // Remove ALICE and BOB from collators

95

1

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

96

1

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

97

1

])

98

1

        .build()

99

1

        .execute_with(|| {

100

1

            assert_eq!(

101

1

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

102

1

                210_000 * UNIT,

103

1

);

104

1

            assert_eq!(

105

1

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

106

1

                100_000 * UNIT,

107

1

);

108

1

});

109

1

110

111

#[test]

112

1

fn genesis_para_registrar() {

113

1

    ExtBuilder::default()

114

1

        .with_empty_parachains(vec![1001, 1002])

115

1

        .build()

116

1

        .execute_with(|| {

117

1

            assert_eq!(

118

1

                Registrar::registered_para_ids(),

119

1

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

120

1

);

121

1

});

122

1

123

124

#[test]

125

1

fn genesis_para_registrar_deregister() {

126

1

    ExtBuilder::default()

127

1

        .with_empty_parachains(vec![1001, 1002])

128

1

        .build()

129

1

        .execute_with(|| {

130

1

            assert_eq!(

131

1

                Registrar::registered_para_ids(),

132

1

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

133

1

);

134

135

1

            run_to_block(2);

136

1

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

137

138

            // Pending

139

1

            assert_eq!(

140

1

                Registrar::pending_registered_para_ids(),

141

1

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

142

1

);

143

144

1

            run_to_session(1);

145

1

            assert_eq!(

146

1

                Registrar::pending_registered_para_ids(),

147

1

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

148

1

);

149

1

            assert_eq!(

150

1

                Registrar::registered_para_ids(),

151

1

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

152

1

);

153

154

1

            run_to_session(2);

155

1

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

156

1

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

157

1

});

158

1

159

160

#[test]

161

1

fn genesis_para_registrar_runtime_api() {

162

1

    ExtBuilder::default()

163

1

        .with_empty_parachains(vec![1001, 1002])

164

1

        .build()

165

1

        .execute_with(|| {

166

1

            assert_eq!(

167

1

                Registrar::registered_para_ids(),

168

1

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

169

1

);

170

1

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

171

172

1

            run_to_block(2);

173

1

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

174

1

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

175

176

1

            run_to_session(1);

177

1

            assert_eq!(

178

1

                Registrar::registered_para_ids(),

179

1

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

180

1

);

181

1

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

182

183

1

            run_to_session(2);

184

1

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

185

1

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

186

1

});

187

1

188

189

#[test]

190

1

fn genesis_para_registrar_container_chain_genesis_data_runtime_api() {

191

1

    let genesis_data_1001 = empty_genesis_data();

192

1

    let genesis_data_1002 = ContainerChainGenesisData {

193

1

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

194

1

        name: Default::default(),

195

1

        id: Default::default(),

196

1

        fork_id: Default::default(),

197

1

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

198

1

        properties: Default::default(),

199

1

};

200

1

    ExtBuilder::default()

201

1

        .with_para_ids(vec![

202

1

            ParaRegistrationParams {

203

1

                para_id: 1001,

204

1

                genesis_data: genesis_data_1001.clone(),

205

1

                block_production_credits: u32::MAX,

206

1

                collator_assignment_credits: u32::MAX,

207

1

                parathread_params: None,

208

1

            },ParaRegistrationParams {

209

1

                para_id: 1002,

210

1

                genesis_data: genesis_data_1002.clone(),

211

1

                block_production_credits: u32::MAX,

212

1

                collator_assignment_credits: u32::MAX,

213

1

                parathread_params: None,

214

1

            },        ])

215

1

        .build()

216

1

        .execute_with(|| {

217

1

            assert_eq!(

218

1

                Registrar::registered_para_ids(),

219

1

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

220

1

);

221

1

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

222

223

1

            assert_eq!(

224

1

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

225

1

                Some(&genesis_data_1001)

226

1

);

227

1

            assert_eq!(

228

1

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

229

1

                Some(&genesis_data_1002)

230

1

);

231

1

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

232

233

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

234

            // with id 100

235

            // TODO: where is that 100 defined?

236

1

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

237

238

1

            run_to_block(2);

239

1

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

240

241

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

242

243

1

            let genesis_data_1003 = ContainerChainGenesisData {

244

1

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

245

1

                name: Default::default(),

246

1

                id: Default::default(),

247

1

                fork_id: Default::default(),

248

1

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

249

1

                properties: Default::default(),

250

1

};

251

1

            assert_ok!(

252

1

                Registrar::register(

253

1

                    origin_of(ALICE.into()),

254

1

                    1003.into(),

255

1

                    genesis_data_1003.clone(),

256

1

                    None

257

1

),

258

1

()

259

1

);

260

261

            // Registered container chains are inserted immediately

262

1

            assert_eq!(

263

1

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

264

1

                Some(&genesis_data_1003)

265

1

);

266

267

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

268

1

            run_to_session(2u32);

269

1

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

270

1

});

271

1

272

273

#[test]

274

1

fn test_author_collation_aura() {

275

1

    ExtBuilder::default()

276

1

        .with_empty_parachains(vec![1001, 1002])

277

1

        .build()

278

1

        .execute_with(|| {

279

1

            run_to_block(5);

280

1

            // Assert current slot gets updated

281

1

            assert_eq!(current_slot(), 4u64);

282

            // slot 4, alice

283

1

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

284

285

1

            run_to_block(6);

286

1

287

1

            assert_eq!(current_slot(), 5u64);

288

            // slot 5, bob

289

1

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

290

1

});

291

1

292

293

#[test]

294

1

fn test_author_collation_aura_change_of_authorities_on_session() {

295

1

    ExtBuilder::default()

296

1

        .with_balances(vec![

297

1

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

298

1

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

299

1

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

300

1

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

301

1

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

302

1

])

303

1

        .with_empty_parachains(vec![1001, 1002])

304

1

        .build()

305

1

        .execute_with(|| {

306

1

            run_to_block(2);

307

1

            // Assert current slot gets updated

308

1

            assert_eq!(current_slot(), 1u64);

309

1

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

310

311

            // We change invulnerables

312

            // We first need to set the keys

313

1

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

314

1

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

315

1

316

1

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

317

1

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

318

1

319

1

            // Set CHARLIE and DAVE keys

320

1

            assert_ok!(Session::set_keys(

321

1

                origin_of(CHARLIE.into()),

322

1

                crate::SessionKeys {

323

1

                    nimbus: charlie_id.clone(),

324

1

},

325

1

                vec![]

326

1

));

327

1

            assert_ok!(Session::set_keys(

328

1

                origin_of(DAVE.into()),

329

1

                crate::SessionKeys {

330

1

                    nimbus: dave_id.clone(),

331

1

},

332

1

                vec![]

333

1

));

334

335

            // Change invulnerables

336

1

            assert_ok!(Invulnerables::remove_invulnerable(

337

1

                root_origin(),

338

1

                ALICE.into()

339

1

));

340

1

            assert_ok!(Invulnerables::remove_invulnerable(

341

1

                root_origin(),

342

1

                BOB.into()

343

1

));

344

1

            assert_ok!(Invulnerables::add_invulnerable(

345

1

                root_origin(),

346

1

                CHARLIE.into()

347

1

));

348

1

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

349

350

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

351

1

            run_to_session(1u32);

352

1

            let author = get_orchestrator_current_author().unwrap();

353

1

354

1

            assert_eq!(current_author(), author);

355

1

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

356

357

            // Invulnerables should have triggered on new session authorities change

358

1

            run_to_session(2u32);

359

1

            let author_after_changes = get_orchestrator_current_author().unwrap();

360

1

361

1

            assert_eq!(current_author(), author_after_changes);

362

1

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

363

1

});

364

1

365

366

#[test]

367

1

fn test_author_collation_aura_add_assigned_to_paras() {

368

1

    ExtBuilder::default()

369

1

        .with_balances(vec![

370

1

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

371

1

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

372

1

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

373

1

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

374

1

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

375

1

])

376

1

        .with_empty_parachains(vec![1001, 1002])

377

1

        .build()

378

1

        .execute_with(|| {

379

1

            run_to_block(2);

380

1

            // Assert current slot gets updated

381

1

            assert_eq!(current_slot(), 1u64);

382

1

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

383

384

            // We change invulnerables

385

            // We first need to set the keys

386

1

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

387

1

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

388

1

389

1

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

390

1

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

391

1

392

1

            // Set CHARLIE and DAVE keys

393

1

            assert_ok!(Session::set_keys(

394

1

                origin_of(CHARLIE.into()),

395

1

                crate::SessionKeys { nimbus: charlie_id },

396

1

                vec![]

397

1

));

398

1

            assert_ok!(Session::set_keys(

399

1

                origin_of(DAVE.into()),

400

1

                crate::SessionKeys { nimbus: dave_id },

401

1

                vec![]

402

1

));

403

404

            // Add new invulnerables

405

1

            assert_ok!(Invulnerables::add_invulnerable(

406

1

                root_origin(),

407

1

                CHARLIE.into()

408

1

));

409

1

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

410

411

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

412

1

            run_to_session(1u32);

413

1

            let author = get_orchestrator_current_author().unwrap();

414

1

415

1

            assert_eq!(current_author(), author);

416

1

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

417

418

            // Invulnerables should have triggered on new session authorities change

419

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

420

1

            run_to_session(2u32);

421

1

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

422

1

            let assignment = CollatorAssignment::collator_container_chain();

423

1

            assert_eq!(

424

1

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

425

1

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

426

1

);

427

1

});

428

1

429

430

#[test]

431

1

fn test_authors_without_paras() {

432

1

    ExtBuilder::default()

433

1

        .with_balances(vec![

434

1

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

435

1

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

436

1

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

437

1

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

438

1

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

439

1

])

440

1

        .with_collators(vec![

441

1

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

442

1

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

443

1

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

444

1

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

445

1

])

446

1

        .build()

447

1

        .execute_with(|| {

448

1

            run_to_block(2);

449

1

            // Assert current slot gets updated

450

1

            assert_eq!(current_slot(), 1u64);

451

1

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

452

453

            // Only Alice and Bob collate for our chain

454

1

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

455

1

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

456

1

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

457

1

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

458

1

459

1

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

460

1

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

461

462

            // Set moondance collators to min 2 max 5

463

1

            assert_ok!(

464

1

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

465

1

()

466

1

);

467

1

            assert_ok!(

468

1

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

469

1

()

470

1

);

471

472

1

            run_to_session(2);

473

1

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

474

1

});

475

1

476

477

#[test]

478

1

fn test_authors_paras_inserted_a_posteriori() {

479

1

    ExtBuilder::default()

480

1

        .with_balances(vec![

481

1

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

482

1

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

483

1

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

484

1

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

485

1

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

486

1

])

487

1

        .with_collators(vec![

488

1

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

489

1

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

490

1

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

491

1

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

492

1

])

493

1

        .build()

494

1

        .execute_with(|| {

495

1

            run_to_block(2);

496

1

            // Assert current slot gets updated

497

1

            assert_eq!(current_slot(), 1u64);

498

1

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

499

500

            // Alice and Bob collate in our chain

501

1

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

502

1

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

503

1

504

1

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

505

506

1

            assert_ok!(Registrar::register(

507

1

                origin_of(ALICE.into()),

508

1

                1001.into(),

509

1

                empty_genesis_data(),

510

1

                None

511

1

));

512

1

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

513

1

            assert_ok!(Registrar::mark_valid_for_collating(

514

1

                root_origin(),

515

1

                1001.into()

516

1

));

517

1

            assert_ok!(ServicesPayment::purchase_credits(

518

1

                origin_of(ALICE.into()),

519

1

                1001.into(),

520

1

                block_credits_to_required_balance(1000, 1001.into())

521

1

));

522

1

            assert_ok!(Registrar::register(

523

1

                origin_of(ALICE.into()),

524

1

                1002.into(),

525

1

                empty_genesis_data(),

526

1

                None

527

1

));

528

1

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

529

1

            assert_ok!(Registrar::mark_valid_for_collating(

530

1

                root_origin(),

531

1

                1002.into()

532

1

));

533

1

            assert_ok!(ServicesPayment::purchase_credits(

534

1

                origin_of(ALICE.into()),

535

1

                1002.into(),

536

1

                block_credits_to_required_balance(1000, 1002.into())

537

1

));

538

539

            // Assignment should happen after 2 sessions

540

1

            run_to_session(1u32);

541

1

            let assignment = CollatorAssignment::collator_container_chain();

542

1

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

543

1

            run_to_session(2u32);

544

1

545

1

            // Charlie and Dave should be assigned to para 1001

546

1

            let assignment = CollatorAssignment::collator_container_chain();

547

1

            assert_eq!(

548

1

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

549

1

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

550

1

);

551

1

});

552

1

553

554

#[test]

555

1

fn test_authors_paras_inserted_a_posteriori_with_collators_already_assigned() {

556

1

    ExtBuilder::default()

557

1

        .with_balances(vec![

558

1

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

559

1

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

560

1

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

561

1

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

562

1

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

563

1

])

564

1

        .with_collators(vec![

565

1

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

566

1

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

567

1

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

568

1

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

569

1

])

570

1

        .with_config(pallet_configuration::HostConfiguration {

571

1

            max_collators: 100,

572

1

            min_orchestrator_collators: 2,

573

1

            max_orchestrator_collators: 5,

574

1

            collators_per_container: 2,

575

1

            full_rotation_period: 0,

576

1

            ..Default::default()

577

1

})

578

1

        .build()

579

1

        .execute_with(|| {

580

1

            run_to_block(2);

581

1

            // Assert current slot gets updated

582

1

            assert_eq!(current_slot(), 1u64);

583

1

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

584

585

            // Alice and Bob collate in our chain

586

1

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

587

1

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

588

1

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

589

1

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

590

1

591

1

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

592

593

1

            assert_ok!(Registrar::register(

594

1

                origin_of(ALICE.into()),

595

1

                1001.into(),

596

1

                empty_genesis_data(),

597

1

                None

598

1

));

599

1

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

600

1

            assert_ok!(Registrar::mark_valid_for_collating(

601

1

                root_origin(),

602

1

                1001.into()

603

1

));

604

1

            assert_ok!(ServicesPayment::purchase_credits(

605

1

                origin_of(ALICE.into()),

606

1

                1001.into(),

607

1

                block_credits_to_required_balance(1000, 1001.into())

608

1

));

609

610

            // Assignment should happen after 2 sessions

611

1

            run_to_session(1u32);

612

1

            let assignment = CollatorAssignment::collator_container_chain();

613

1

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

614

1

            run_to_session(2u32);

615

1

616

1

            // Charlie and Dave are now assigned to para 1001

617

1

            let assignment = CollatorAssignment::collator_container_chain();

618

1

            assert_eq!(

619

1

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

620

1

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

621

1

);

622

1

            assert_eq!(

623

1

                assignment.orchestrator_chain,

624

1

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

625

1

);

626

1

});

627

1

628

629

#[test]

630

1

fn test_paras_registered_but_zero_credits() {

631

1

    ExtBuilder::default()

632

1

        .with_balances(vec![

633

1

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

634

1

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

635

1

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

636

1

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

637

1

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

638

1

])

639

1

        .with_collators(vec![

640

1

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

641

1

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

642

1

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

643

1

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

644

1

])

645

1

        .build()

646

1

        .execute_with(|| {

647

1

            run_to_block(2);

648

1

            // Assert current slot gets updated

649

1

            assert_eq!(current_slot(), 1u64);

650

1

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

651

652

            // Alice and Bob collate in our chain

653

1

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

654

1

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

655

1

656

1

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

657

658

1

            assert_ok!(Registrar::register(

659

1

                origin_of(ALICE.into()),

660

1

                1001.into(),

661

1

                empty_genesis_data(),

662

1

                None

663

1

));

664

1

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

665

1

            assert_ok!(Registrar::mark_valid_for_collating(

666

1

                root_origin(),

667

1

                1001.into()

668

1

));

669

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

670

1

            assert_ok!(ServicesPayment::set_block_production_credits(

671

1

                root_origin(),

672

1

                1001.into(),

673

1

674

1

));

675

676

            // Assignment should happen after 2 sessions

677

1

            run_to_session(1u32);

678

1

            let assignment = CollatorAssignment::collator_container_chain();

679

1

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

680

1

            run_to_session(2u32);

681

1

682

1

            // Nobody should be assigned to para 1001

683

1

            let assignment = CollatorAssignment::collator_container_chain();

684

1

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

685

1

});

686

1

687

688

#[test]

689

1

fn test_paras_registered_but_not_enough_credits() {

690

1

    ExtBuilder::default()

691

1

        .with_balances(vec![

692

1

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

693

1

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

694

1

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

695

1

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

696

1

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

697

1

])

698

1

        .with_collators(vec![

699

1

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

700

1

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

701

1

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

702

1

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

703

1

])

704

1

        .build()

705

1

        .execute_with(|| {

706

1

            run_to_block(2);

707

1

            // Assert current slot gets updated

708

1

            assert_eq!(current_slot(), 1u64);

709

1

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

710

711

            // Alice and Bob collate in our chain

712

1

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

713

1

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

714

1

715

1

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

716

717

1

            assert_ok!(Registrar::register(

718

1

                origin_of(ALICE.into()),

719

1

                1001.into(),

720

1

                empty_genesis_data(),

721

1

                None

722

1

));

723

1

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

724

1

            assert_ok!(Registrar::mark_valid_for_collating(

725

1

                root_origin(),

726

1

                1001.into()

727

1

));

728

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

729

1

            assert_ok!(ServicesPayment::set_block_production_credits(

730

1

                root_origin(),

731

1

                1001.into(),

732

1

733

1

));

734

            // Purchase 1 credit less that what is needed

735

1

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

736

1

            assert_ok!(ServicesPayment::set_block_production_credits(

737

1

                root_origin(),

738

1

                1001.into(),

739

1

                credits_1001

740

1

));

741

742

            // Assignment should happen after 2 sessions

743

1

            run_to_session(1u32);

744

1

            let assignment = CollatorAssignment::collator_container_chain();

745

1

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

746

1

            run_to_session(2u32);

747

1

            // Nobody should be assigned to para 1001

748

1

            let assignment = CollatorAssignment::collator_container_chain();

749

1

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

750

751

            // Now purchase the missing block credit

752

1

            assert_ok!(ServicesPayment::set_block_production_credits(

753

1

                root_origin(),

754

1

                1001.into(),

755

1

                credits_1001 + 1

756

1

));

757

758

1

            run_to_session(4u32);

759

1

            // Charlie and Dave should be assigned to para 1001

760

1

            let assignment = CollatorAssignment::collator_container_chain();

761

1

            assert_eq!(

762

1

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

763

1

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

764

1

);

765

1

});

766

1

767

768

#[test]

769

1

fn test_paras_registered_but_only_credits_for_1_session() {

770

1

    ExtBuilder::default()

771

1

        .with_balances(vec![

772

1

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

773

1

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

774

1

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

775

1

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

776

1

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

777

1

])

778

1

        .with_collators(vec![

779

1

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

780

1

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

781

1

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

782

1

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

783

1

])

784

1

        .build()

785

1

        .execute_with(|| {

786

1

            run_to_block(2);

787

1

            // Assert current slot gets updated

788

1

            assert_eq!(current_slot(), 1u64);

789

1

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

790

791

            // Alice and Bob collate in our chain

792

1

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

793

1

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

794

1

795

1

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

796

797

1

            assert_ok!(Registrar::register(

798

1

                origin_of(ALICE.into()),

799

1

                1001.into(),

800

1

                empty_genesis_data(),

801

1

                None

802

1

));

803

1

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

804

1

            assert_ok!(Registrar::mark_valid_for_collating(

805

1

                root_origin(),

806

1

                1001.into()

807

1

));

808

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

809

1

            assert_ok!(ServicesPayment::set_block_production_credits(

810

1

                root_origin(),

811

1

                1001.into(),

812

1

813

1

));

814

            // Purchase only enough credits for 1 session

815

1

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

816

1

            assert_ok!(ServicesPayment::set_block_production_credits(

817

1

                root_origin(),

818

1

                1001.into(),

819

1

                credits_1001

820

1

));

821

822

            // Assignment should happen after 2 sessions

823

1

            run_to_session(1u32);

824

1

            let assignment = CollatorAssignment::collator_container_chain();

825

1

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

826

1

            run_to_session(2u32);

827

1

            // Charlie and Dave should be assigned to para 1001

828

1

            let assignment = CollatorAssignment::collator_container_chain();

829

1

            assert_eq!(

830

1

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

831

1

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

832

1

);

833

834

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

835

1

            run_block();

836

1

            let credits =

837

1

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

838

1

                    .unwrap_or_default();

839

1

            assert_eq!(credits, credits_1001);

840

841

            // Simulate block inclusion from container chain 1001

842

1

            let mut sproof = ParaHeaderSproofBuilder::default();

843

1

            let slot: u64 = 5;

844

1

            let s = ParaHeaderSproofBuilderItem {

845

1

                para_id: 1001.into(),

846

1

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

847

1

                    parent_hash: Default::default(),

848

1

                    number: 1,

849

1

                    state_root: Default::default(),

850

1

                    extrinsics_root: Default::default(),

851

1

                    digest: sp_runtime::generic::Digest {

852

1

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

853

1

},

854

1

}),

855

1

};

856

1

            sproof.items.push(s);

857

1

            set_author_noting_inherent_data(sproof);

858

1

859

1

            run_block();

860

1

            let credits =

861

1

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

862

1

                    .unwrap_or_default();

863

1

            assert_eq!(credits, credits_1001 - 1);

864

865

1

            run_to_session(4u32);

866

1

            // Nobody should be assigned to para 1001

867

1

            let assignment = CollatorAssignment::collator_container_chain();

868

1

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

869

870

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

871

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

872

1

            let credits =

873

1

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

874

1

                    .unwrap_or_default();

875

1

            assert_eq!(credits, credits_1001 - 1);

876

1

});

877

1

878

879

#[test]

880

1

fn test_parachains_deregister_collators_re_assigned() {

881

1

    ExtBuilder::default()

882

1

        .with_balances(vec![

883

1

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

884

1

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

885

1

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

886

1

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

887

1

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

888

1

])

889

1

        .with_collators(vec![

890

1

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

891

1

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

892

1

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

893

1

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

894

1

])

895

1

        .with_empty_parachains(vec![1001, 1002])

896

1

        .build()

897

1

        .execute_with(|| {

898

1

            run_to_block(2);

899

1

            // Assert current slot gets updated

900

1

            assert_eq!(current_slot(), 1u64);

901

1

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

902

903

            // Alice and Bob are authorities

904

1

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

905

1

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

906

1

907

1

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

908

909

            // Charlie and Dave to 1001

910

1

            let assignment = CollatorAssignment::collator_container_chain();

911

1

            assert_eq!(

912

1

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

913

1

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

914

1

);

915

916

1

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

917

918

            // Assignment should happen after 2 sessions

919

1

            run_to_session(1u32);

920

1

921

1

            let assignment = CollatorAssignment::collator_container_chain();

922

1

            assert_eq!(

923

1

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

924

1

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

925

1

);

926

927

1

            run_to_session(2u32);

928

1

929

1

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

930

1

            let assignment = CollatorAssignment::collator_container_chain();

931

1

            assert_eq!(

932

1

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

933

1

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

934

1

);

935

1

});

936

1

937

938

#[test]

939

1

fn test_parachains_deregister_collators_config_change_reassigned() {

940

1

    ExtBuilder::default()

941

1

        .with_balances(vec![

942

1

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

943

1

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

944

1

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

945

1

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

946

1

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

947

1

])

948

1

        .with_collators(vec![

949

1

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

950

1

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

951

1

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

952

1

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

953

1

])

954

1

        .with_empty_parachains(vec![1001, 1002])

955

1

        .build()

956

1

        .execute_with(|| {

957

1

            run_to_block(2);

958

1

            // Assert current slot gets updated

959

1

            assert_eq!(current_slot(), 1u64);

960

1

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

961

962

            // Alice and Bob are authorities

963

1

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

964

1

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

965

1

966

1

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

967

968

            // Set orchestrator collators to 1

969

1

            assert_ok!(

970

1

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

971

1

()

972

1

);

973

974

            // Set container chain collators to 3

975

1

            assert_ok!(

976

1

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

977

1

()

978

1

);

979

980

            // Charlie and Dave to 1001

981

1

            let assignment = CollatorAssignment::collator_container_chain();

982

1

            assert_eq!(

983

1

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

984

1

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

985

1

);

986

987

            // Assignment should happen after 2 sessions

988

1

            run_to_session(1u32);

989

1

990

1

            let assignment = CollatorAssignment::collator_container_chain();

991

1

            assert_eq!(

992

1

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

993

1

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

994

1

);

995

996

1

            run_to_session(2u32);

997

1

998

1

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

999

1

            let assignment = CollatorAssignment::collator_container_chain();

1000

1

            assert_eq!(

1001

1

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

1002

1

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

1003

1

);

1004

1005

1

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

1006

1

});

1007

1

1008

1009

#[test]

1010

1

fn test_orchestrator_collators_with_non_sufficient_collators() {

1011

1

    ExtBuilder::default()

1012

1

        .with_balances(vec![

1013

1

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

1014

1

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

1015

1

])

1016

1

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

1017

1

        .with_empty_parachains(vec![1001, 1002])

1018

1

        .build()

1019

1

        .execute_with(|| {

1020

1

            run_to_block(2);

1021

1

            // Assert current slot gets updated

1022

1

            assert_eq!(current_slot(), 1u64);

1023

1

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

1024

1025

            // Alice and Bob are authorities

1026

1

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

1027

1

1028

1

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

1029

1

});

1030

1

1031

1032

#[test]

1033

1

fn test_configuration_on_session_change() {

1034

1

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

1035

1

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

1036

1

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

1037

1

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

1038

1039

1

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

1040

1

        run_to_session(1u32);

1041

1

1042

1

        assert_ok!(

1043

1

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

1044

1

()

1045

1

);

1046

1

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

1047

1

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

1048

1

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

1049

1050

1

        run_to_session(2u32);

1051

1

        assert_ok!(

1052

1

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

1053

1

()

1054

1

);

1055

1

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

1056

1

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

1057

1

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

1058

1059

1

        run_to_session(3u32);

1060

1

1061

1

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

1062

1

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

1063

1

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

1064

1065

1

        run_to_session(4u32);

1066

1

1067

1

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

1068

1

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

1069

1

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

1070

1

});

1071

1

1072

1073

#[test]

1074

1

fn test_author_collation_aura_add_assigned_to_paras_runtime_api() {

1075

1

    ExtBuilder::default()

1076

1

        .with_balances(vec![

1077

1

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

1078

1

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

1079

1

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

1080

1

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

1081

1

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

1082

1

])

1083

1

        .with_empty_parachains(vec![1001, 1002])

1084

1

        .build()

1085

1

        .execute_with(|| {

1086

1

            run_to_block(2);

1087

1

            // Assert current slot gets updated

1088

1

            assert_eq!(current_slot(), 1u64);

1089

1

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

1090

1

            assert_eq!(

1091

1

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

1092

1

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

1093

1

);

1094

1

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

1095

1

            assert_eq!(

1096

1

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

1097

1

                Some(100.into())

1098

1

);

1099

1

            assert_eq!(

1100

1

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

1101

1

                Some(100.into())

1102

1

);

1103

1

            assert_eq!(

1104

1

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

1105

1

                None

1106

1

);

1107

1

            assert_eq!(

1108

1

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

1109

1

                None

1110

1

);

1111

1112

            // We change invulnerables

1113

            // We first need to set the keys

1114

1

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

1115

1

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

1116

1

1117

1

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

1118

1

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

1119

1

1120

1

            // Set CHARLIE and DAVE keys

1121

1

            assert_ok!(Session::set_keys(

1122

1

                origin_of(CHARLIE.into()),

1123

1

                crate::SessionKeys { nimbus: charlie_id },

1124

1

                vec![]

1125

1

));

1126

1

            assert_ok!(Session::set_keys(

1127

1

                origin_of(DAVE.into()),

1128

1

                crate::SessionKeys { nimbus: dave_id },

1129

1

                vec![]

1130

1

));

1131

1132

            // Set new invulnerables

1133

1

            assert_ok!(Invulnerables::add_invulnerable(

1134

1

                root_origin(),

1135

1

                CHARLIE.into()

1136

1

));

1137

1

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

1138

1139

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

1140

1

            run_to_session(1u32);

1141

1

            let author = get_orchestrator_current_author().unwrap();

1142

1

1143

1

            assert_eq!(current_author(), author);

1144

1

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

1145

1

            assert_eq!(

1146

1

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

1147

1

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

1148

1

);

1149

1

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

1150

1

            assert_eq!(

1151

1

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

1152

1

                None

1153

1

);

1154

1

            assert_eq!(

1155

1

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

1156

1

                Some(1001.into())

1157

1

);

1158

1159

            // Invulnerables should have triggered on new session authorities change

1160

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

1161

1

            run_to_session(2u32);

1162

1

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

1163

1

            let assignment = CollatorAssignment::collator_container_chain();

1164

1

            assert_eq!(

1165

1

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

1166

1

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

1167

1

);

1168

1169

1

            assert_eq!(

1170

1

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

1171

1

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

1172

1

);

1173

1

            assert_eq!(

1174

1

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

1175

1

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

1176

1

);

1177

1

            assert_eq!(

1178

1

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

1179

1

                Some(1001.into())

1180

1

);

1181

1

            assert_eq!(

1182

1

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

1183

1

                Some(1001.into())

1184

1

);

1185

1186

            // Remove BOB

1187

1

            assert_ok!(Invulnerables::remove_invulnerable(

1188

1

                root_origin(),

1189

1

                BOB.into()

1190

1

));

1191

1192

1

            run_to_session(3u32);

1193

1

            assert_eq!(

1194

1

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

1195

1

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

1196

1

);

1197

1

            assert_eq!(

1198

1

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

1199

1

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

1200

1

);

1201

1

            assert_eq!(

1202

1

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

1203

1

                Some(100.into())

1204

1

);

1205

1

            assert_eq!(

1206

1

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

1207

1

                None

1208

1

);

1209

1210

1

            run_to_session(4u32);

1211

1

            assert_eq!(

1212

1

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

1213

1

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

1214

1

);

1215

1

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

1216

1

            assert_eq!(

1217

1

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

1218

1

                None

1219

1

);

1220

1

            assert_eq!(

1221

1

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

1222

1

                None

1223

1

);

1224

1

});

1225

1

1226

1227

#[test]

1228

1

fn test_consensus_runtime_api() {

1229

1

    ExtBuilder::default()

1230

1

        .with_balances(vec![

1231

1

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

1232

1

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

1233

1

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

1234

1

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

1235

1

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

1236

1

])

1237

1

        .with_empty_parachains(vec![1001, 1002])

1238

1

        .build()

1239

1

        .execute_with(|| {

1240

1

            run_to_block(2);

1241

1

1242

1

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

1243

1

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

1244

1

1245

1

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

1246

1

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

1247

1

1248

1

            assert_eq!(

1249

1

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

1250

1

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

1251

1

);

1252

1

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

1253

1

            assert_eq!(

1254

1

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

1255

1

                Some(100.into())

1256

1

);

1257

1

            assert_eq!(

1258

1

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

1259

1

                Some(100.into())

1260

1

);

1261

1

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

1262

1

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

1263

1264

            // Set CHARLIE and DAVE keys

1265

1

            assert_ok!(Session::set_keys(

1266

1

                origin_of(CHARLIE.into()),

1267

1

                crate::SessionKeys {

1268

1

                    nimbus: charlie_id.clone(),

1269

1

},

1270

1

                vec![]

1271

1

));

1272

1

            assert_ok!(Session::set_keys(

1273

1

                origin_of(DAVE.into()),

1274

1

                crate::SessionKeys {

1275

1

                    nimbus: dave_id.clone(),

1276

1

},

1277

1

                vec![]

1278

1

));

1279

1280

            // Set new invulnerables

1281

1

            assert_ok!(Invulnerables::add_invulnerable(

1282

1

                root_origin(),

1283

1

                CHARLIE.into()

1284

1

));

1285

1

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

1286

1287

1

            run_to_session(2u32);

1288

1

            assert_eq!(

1289

1

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

1290

1

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

1291

1

);

1292

1

            assert_eq!(

1293

1

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

1294

1

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

1295

1

);

1296

1

            assert_eq!(

1297

1

                Runtime::check_para_id_assignment(alice_id),

1298

1

                Some(100.into())

1299

1

);

1300

1

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

1301

1

            assert_eq!(

1302

1

                Runtime::check_para_id_assignment(charlie_id),

1303

1

                Some(1001.into())

1304

1

);

1305

1

            assert_eq!(

1306

1

                Runtime::check_para_id_assignment(dave_id),

1307

1

                Some(1001.into())

1308

1

);

1309

1

});

1310

1

1311

1312

#[test]

1313

1

fn test_consensus_runtime_api_session_changes() {

1314

1

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

1315

1

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

1316

1

    // if we can predict correctly

1317

1

    ExtBuilder::default()

1318

1

        .with_balances(vec![

1319

1

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

1320

1

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

1321

1

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

1322

1

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

1323

1

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

1324

1

])

1325

1

        .with_empty_parachains(vec![1001, 1002])

1326

1

        .build()

1327

1

        .execute_with(|| {

1328

1

            run_to_block(2);

1329

1

1330

1

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

1331

1

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

1332

1

1333

1

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

1334

1

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

1335

1

1336

1

            assert_eq!(

1337

1

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

1338

1

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

1339

1

);

1340

1

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

1341

1

            assert_eq!(

1342

1

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

1343

1

                Some(100.into())

1344

1

);

1345

1

            assert_eq!(

1346

1

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

1347

1

                Some(100.into())

1348

1

);

1349

1

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

1350

1

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

1351

1352

            // Set CHARLIE and DAVE keys

1353

1

            assert_ok!(Session::set_keys(

1354

1

                origin_of(CHARLIE.into()),

1355

1

                crate::SessionKeys {

1356

1

                    nimbus: charlie_id.clone(),

1357

1

},

1358

1

                vec![]

1359

1

));

1360

1

            assert_ok!(Session::set_keys(

1361

1

                origin_of(DAVE.into()),

1362

1

                crate::SessionKeys {

1363

1

                    nimbus: dave_id.clone(),

1364

1

},

1365

1

                vec![]

1366

1

));

1367

1368

            // Set new invulnerables

1369

1

            assert_ok!(Invulnerables::add_invulnerable(

1370

1

                root_origin(),

1371

1

                CHARLIE.into()

1372

1

));

1373

1

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

1374

1375

1

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

1376

1

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

1377

1

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

1378

1

            // edge of a session change

1379

1

            run_to_block(session_two_edge - 2);

1380

1

1381

1

            assert_eq!(

1382

1

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

1383

1

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

1384

1

);

1385

1

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

1386

1

            assert_eq!(

1387

1

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

1388

1

                Some(100.into())

1389

1

);

1390

1

            assert_eq!(

1391

1

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

1392

1

                Some(100.into())

1393

1

);

1394

1

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

1395

1

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

1396

1397

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

1398

            // authorities of the next block!

1399

1

            run_to_block(session_two_edge - 1);

1400

1

            assert_eq!(

1401

1

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

1402

1

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

1403

1

);

1404

1

            assert_eq!(

1405

1

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

1406

1

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

1407

1

);

1408

1

            assert_eq!(

1409

1

                Runtime::check_para_id_assignment(alice_id),

1410

1

                Some(100.into())

1411

1

);

1412

1

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

1413

1

            assert_eq!(

1414

1

                Runtime::check_para_id_assignment(charlie_id),

1415

1

                Some(1001.into())

1416

1

);

1417

1

            assert_eq!(

1418

1

                Runtime::check_para_id_assignment(dave_id),

1419

1

                Some(1001.into())

1420

1

);

1421

1

});

1422

1

1423

1424

#[test]

1425

1

fn test_consensus_runtime_api_next_session() {

1426

1

    ExtBuilder::default()

1427

1

        .with_balances(vec![

1428

1

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

1429

1

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

1430

1

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

1431

1

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

1432

1

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

1433

1

])

1434

1

        .with_empty_parachains(vec![1001, 1002])

1435

1

        .build()

1436

1

        .execute_with(|| {

1437

1

            run_to_block(2);

1438

1

1439

1

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

1440

1

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

1441

1

1442

1

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

1443

1

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

1444

1

1445

1

            assert_eq!(

1446

1

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

1447

1

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

1448

1

);

1449

1

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

1450

1

            assert_eq!(

1451

1

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

1452

1

                Some(100.into())

1453

1

);

1454

1

            assert_eq!(

1455

1

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

1456

1

                Some(100.into())

1457

1

);

1458

1

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

1459

1

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

1460

1461

            // In the next session the assignment will not change

1462

1

            assert_eq!(

1463

1

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

1464

1

                Some(100.into())

1465

1

);

1466

1

            assert_eq!(

1467

1

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

1468

1

                Some(100.into())

1469

1

);

1470

1

            assert_eq!(

1471

1

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

1472

1

                None,

1473

1

);

1474

1

            assert_eq!(

1475

1

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

1476

1

                None,

1477

1

);

1478

1479

            // Set CHARLIE and DAVE keys

1480

1

            assert_ok!(Session::set_keys(

1481

1

                origin_of(CHARLIE.into()),

1482

1

                crate::SessionKeys {

1483

1

                    nimbus: charlie_id.clone(),

1484

1

},

1485

1

                vec![]

1486

1

));

1487

1

            assert_ok!(Session::set_keys(

1488

1

                origin_of(DAVE.into()),

1489

1

                crate::SessionKeys {

1490

1

                    nimbus: dave_id.clone(),

1491

1

},

1492

1

                vec![]

1493

1

));

1494

1495

            // Set new invulnerables

1496

1

            assert_ok!(Invulnerables::add_invulnerable(

1497

1

                root_origin(),

1498

1

                CHARLIE.into()

1499

1

));

1500

1

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

1501

1502

1

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

1503

1

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

1504

1

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

1505

1

            // edge of a session change

1506

1

            run_to_block(session_two_edge - 2);

1507

1

1508

1

            assert_eq!(

1509

1

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

1510

1

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

1511

1

);

1512

1

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

1513

1

            assert_eq!(

1514

1

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

1515

1

                Some(100.into())

1516

1

);

1517

1

            assert_eq!(

1518

1

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

1519

1

                Some(100.into())

1520

1

);

1521

1

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

1522

1

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

1523

1524

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

1525

1

            assert_eq!(

1526

1

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

1527

1

                Some(100.into())

1528

1

);

1529

1

            assert_eq!(

1530

1

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

1531

1

                Some(100.into())

1532

1

);

1533

1

            assert_eq!(

1534

1

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

1535

1

                Some(1001.into()),

1536

1

);

1537

1

            assert_eq!(

1538

1

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

1539

1

                Some(1001.into()),

1540

1

);

1541

1542

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

1543

            // authorities of the next block!

1544

1

            run_to_block(session_two_edge - 1);

1545

1

            assert_eq!(

1546

1

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

1547

1

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

1548

1

);

1549

1

            assert_eq!(

1550

1

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

1551

1

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

1552

1

);

1553

1

            assert_eq!(

1554

1

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

1555

1

                Some(100.into())

1556

1

);

1557

1

            assert_eq!(

1558

1

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

1559

1

                Some(100.into())

1560

1

);

1561

1

            assert_eq!(

1562

1

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

1563

1

                Some(1001.into())

1564

1

);

1565

1

            assert_eq!(

1566

1

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

1567

1

                Some(1001.into())

1568

1

);

1569

1570

            // check_para_id_assignment_next_session returns the same value as check_para_id_assignment

1571

            // because we are on a session boundary

1572

1

            assert_eq!(

1573

1

                Runtime::check_para_id_assignment_next_session(alice_id),

1574

1

                Some(100.into())

1575

1

);

1576

1

            assert_eq!(

1577

1

                Runtime::check_para_id_assignment_next_session(bob_id),

1578

1

                Some(100.into())

1579

1

);

1580

1

            assert_eq!(

1581

1

                Runtime::check_para_id_assignment_next_session(charlie_id),

1582

1

                Some(1001.into())

1583

1

);

1584

1

            assert_eq!(

1585

1

                Runtime::check_para_id_assignment_next_session(dave_id),

1586

1

                Some(1001.into())

1587

1

);

1588

1

});

1589

1

1590

1591

#[test]

1592

1

fn test_author_noting_self_para_id_not_noting() {

1593

1

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

1594

1

        let mut sproof = ParaHeaderSproofBuilder::default();

1595

1

        let slot: u64 = 5;

1596

1

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

1597

1

        let s = ParaHeaderSproofBuilderItem {

1598

1

            para_id: self_para,

1599

1

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

1600

1

                parent_hash: Default::default(),

1601

1

                number: Default::default(),

1602

1

                state_root: Default::default(),

1603

1

                extrinsics_root: Default::default(),

1604

1

                digest: sp_runtime::generic::Digest {

1605

1

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

1606

1

},

1607

1

}),

1608

1

};

1609

1

        sproof.items.push(s);

1610

1

1611

1

        set_author_noting_inherent_data(sproof);

1612

1

1613

1

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

1614

1

});

1615

1

1616

1617

#[test]

1618

1

fn test_author_noting_not_self_para() {

1619

1

    ExtBuilder::default()

1620

1

        .with_balances(vec![

1621

1

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

1622

1

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

1623

1

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

1624

1

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

1625

1

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

1626

1

])

1627

1

        .with_collators(vec![

1628

1

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

1629

1

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

1630

1

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

1631

1

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

1632

1

])

1633

1

        .with_empty_parachains(vec![1001, 1002])

1634

1

        .build()

1635

1

        .execute_with(|| {

1636

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1637

1

            let slot: u64 = 5;

1638

1

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

1639

1

1640

1

            // Charlie and Dave to 1001

1641

1

            let assignment = CollatorAssignment::collator_container_chain();

1642

1

            assert_eq!(

1643

1

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

1644

1

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

1645

1

);

1646

1647

1

            let s = ParaHeaderSproofBuilderItem {

1648

1

                para_id: other_para,

1649

1

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

1650

1

                    parent_hash: Default::default(),

1651

1

                    number: 1,

1652

1

                    state_root: Default::default(),

1653

1

                    extrinsics_root: Default::default(),

1654

1

                    digest: sp_runtime::generic::Digest {

1655

1

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

1656

1

},

1657

1

}),

1658

1

};

1659

1

            sproof.items.push(s);

1660

1

1661

1

            set_author_noting_inherent_data(sproof);

1662

1

1663

1

            assert_eq!(

1664

1

                AuthorNoting::latest_author(other_para),

1665

1

                Some(ContainerChainBlockInfo {

1666

1

                    block_number: 1,

1667

1

                    author: AccountId::from(DAVE),

1668

1

                    latest_slot_number: 0.into(),

1669

1

})

1670

1

);

1671

1

});

1672

1

1673

1674

#[test]

1675

1

fn test_author_noting_set_author_and_kill_author_data() {

1676

1

    ExtBuilder::default()

1677

1

        .with_balances(vec![

1678

1

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

1679

1

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

1680

1

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

1681

1

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

1682

1

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

1683

1

])

1684

1

        .with_collators(vec![

1685

1

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

1686

1

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

1687

1

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

1688

1

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

1689

1

])

1690

1

        .with_empty_parachains(vec![1001, 1002])

1691

1

        .build()

1692

1

        .execute_with(|| {

1693

1

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

1694

1

1695

1

            assert_ok!(AuthorNoting::set_author(

1696

1

                root_origin(),

1697

1

                other_para,

1698

1

1,

1699

1

                AccountId::from(DAVE),

1700

1

                1.into()

1701

1

));

1702

1703

1

            assert_eq!(

1704

1

                AuthorNoting::latest_author(other_para),

1705

1

                Some(ContainerChainBlockInfo {

1706

1

                    block_number: 1,

1707

1

                    author: AccountId::from(DAVE),

1708

1

                    latest_slot_number: 1.into(),

1709

1

})

1710

1

);

1711

1712

1

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

1713

1714

1

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

1715

1

});

1716

1

1717

1718

#[test]

1719

1

fn test_author_noting_set_author_and_kill_author_data_bad_origin() {

1720

1

    ExtBuilder::default()

1721

1

        .with_balances(vec![

1722

1

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

1723

1

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

1724

1

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

1725

1

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

1726

1

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

1727

1

])

1728

1

        .with_collators(vec![

1729

1

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

1730

1

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

1731

1

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

1732

1

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

1733

1

])

1734

1

        .with_empty_parachains(vec![1001, 1002])

1735

1

        .build()

1736

1

        .execute_with(|| {

1737

1

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

1738

1

1739

1

            assert_noop!(

1740

1

                AuthorNoting::set_author(

1741

1

                    origin_of(ALICE.into()),

1742

1

                    other_para,

1743

1

1,

1744

1

                    AccountId::from(DAVE),

1745

1

                    1.into()

1746

1

),

1747

1

                BadOrigin

1748

1

);

1749

1750

1

            assert_noop!(

1751

1

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

1752

1

                BadOrigin

1753

1

);

1754

1

});

1755

1

1756

1757

#[test]

1758

1

fn test_author_noting_runtime_api() {

1759

1

    ExtBuilder::default()

1760

1

        .with_balances(vec![

1761

1

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

1762

1

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

1763

1

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

1764

1

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

1765

1

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

1766

1

])

1767

1

        .with_collators(vec![

1768

1

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

1769

1

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

1770

1

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

1771

1

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

1772

1

])

1773

1

        .with_empty_parachains(vec![1001, 1002])

1774

1

        .build()

1775

1

        .execute_with(|| {

1776

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1777

1

            let slot: u64 = 5;

1778

1

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

1779

1

1780

1

            // Charlie and Dave to 1001

1781

1

            let assignment = CollatorAssignment::collator_container_chain();

1782

1

            assert_eq!(

1783

1

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

1784

1

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

1785

1

);

1786

1787

1

            let s = ParaHeaderSproofBuilderItem {

1788

1

                para_id: other_para,

1789

1

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

1790

1

                    parent_hash: Default::default(),

1791

1

                    number: 1,

1792

1

                    state_root: Default::default(),

1793

1

                    extrinsics_root: Default::default(),

1794

1

                    digest: sp_runtime::generic::Digest {

1795

1

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

1796

1

},

1797

1

}),

1798

1

};

1799

1

            sproof.items.push(s);

1800

1

1801

1

            set_author_noting_inherent_data(sproof);

1802

1

1803

1

            assert_eq!(

1804

1

                AuthorNoting::latest_author(other_para),

1805

1

                Some(ContainerChainBlockInfo {

1806

1

                    block_number: 1,

1807

1

                    author: AccountId::from(DAVE),

1808

1

                    latest_slot_number: 0.into(),

1809

1

})

1810

1

);

1811

1812

1

            assert_eq!(

1813

1

                Runtime::latest_author(other_para),

1814

1

                Some(AccountId::from(DAVE))

1815

1

);

1816

1

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

1817

1

});

1818

1

1819

1820

#[test]

1821

1

fn session_keys_key_type_id() {

1822

1

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

1823

1

1824

1825

#[test]

1826

1

fn test_session_keys_with_authority_mapping() {

1827

1

    ExtBuilder::default()

1828

1

        .with_balances(vec![

1829

1

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

1830

1

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

1831

1

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

1832

1

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

1833

1

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

1834

1

])

1835

1

        .with_empty_parachains(vec![1001, 1002])

1836

1

        .build()

1837

1

        .execute_with(|| {

1838

1

            run_to_block(2);

1839

1

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

1840

1

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

1841

1

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

1842

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1843

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1844

1

1845

1

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

1846

1

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

1847

1

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

1848

1849

            // Everything should match to aura

1850

1

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

1851

1852

            // Change Alice and Bob keys to something different

1853

            // for now lets change it to alice_2 and bob_2

1854

1

            assert_ok!(Session::set_keys(

1855

1

                origin_of(ALICE.into()),

1856

1

                crate::SessionKeys {

1857

1

                    nimbus: alice_id_2.clone(),

1858

1

},

1859

1

                vec![]

1860

1

));

1861

1

            assert_ok!(Session::set_keys(

1862

1

                origin_of(BOB.into()),

1863

1

                crate::SessionKeys {

1864

1

                    nimbus: bob_id_2.clone(),

1865

1

},

1866

1

                vec![]

1867

1

));

1868

1869

1

            run_to_session(1u32);

1870

1

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

1871

1

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

1872

1

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

1873

1

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

1874

1875

1

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

1876

1

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

1877

1

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

1878

1

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

1879

1880

            // Everything should match to aura

1881

1

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

1882

//

1883

1884

1

            run_to_session(2u32);

1885

1

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

1886

1887

1

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

1888

1

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

1889

1

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

1890

1

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

1891

1892

1

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

1893

1

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

1894

1

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

1895

1

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

1896

1897

            // Everything should match to aura

1898

1

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

1899

1

});

1900

1

1901

1902

#[test]

1903

1

fn test_session_keys_with_authority_assignment() {

1904

1

    ExtBuilder::default()

1905

1

        .with_balances(vec![

1906

1

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

1907

1

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

1908

1

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

1909

1

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

1910

1

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

1911

1

])

1912

1

        .with_empty_parachains(vec![1001, 1002])

1913

1

        .build()

1914

1

        .execute_with(|| {

1915

1

            run_to_block(2);

1916

1

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

1917

1

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

1918

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1919

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1920

1

1921

1

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

1922

1

            assert_eq!(

1923

1

                key_mapping_session_0.orchestrator_chain,

1924

1

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

1925

1

);

1926

1

            assert_eq!(

1927

1

                CollatorAssignment::collator_container_chain().orchestrator_chain,

1928

1

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

1929

1

);

1930

1931

1

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

1932

1

            assert_eq!(key_mapping_session_1, key_mapping_session_0,);

1933

1

            let old_assignment_session_1 =

1934

1

                CollatorAssignment::pending_collator_container_chain().unwrap();

1935

1

            assert_eq!(

1936

1

                old_assignment_session_1,

1937

1

                CollatorAssignment::collator_container_chain(),

1938

1

);

1939

1940

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2);

1941

1

            assert!(key_mapping_session_2.is_none());

1942

1943

            // Everything should match to aura

1944

1

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

1945

1946

            // Change Alice and Bob keys to something different

1947

            // for now lets change it to alice_2 and bob_2

1948

1

            assert_ok!(Session::set_keys(

1949

1

                origin_of(ALICE.into()),

1950

1

                crate::SessionKeys {

1951

1

                    nimbus: alice_id_2.clone(),

1952

1

},

1953

1

                vec![]

1954

1

));

1955

1

            assert_ok!(Session::set_keys(

1956

1

                origin_of(BOB.into()),

1957

1

                crate::SessionKeys {

1958

1

                    nimbus: bob_id_2.clone(),

1959

1

},

1960

1

                vec![]

1961

1

));

1962

1963

1

            run_to_session(1u32);

1964

1

            let old_key_mapping_session_1 = key_mapping_session_1;

1965

1

1966

1

            // Session 0 got removed

1967

1

            let key_mapping_session_0 = AuthorityAssignment::collator_container_chain(0);

1968

1

            assert!(key_mapping_session_0.is_none());

1969

1970

            // The values at session 1 did not change

1971

1

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

1972

1

            assert_eq!(key_mapping_session_1, old_key_mapping_session_1,);

1973

1

            assert_eq!(

1974

1

                CollatorAssignment::collator_container_chain(),

1975

1

                old_assignment_session_1,

1976

1

);

1977

1978

            // Session 2 uses the new keys

1979

1

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

1980

1

            assert_eq!(

1981

1

                key_mapping_session_2.orchestrator_chain,

1982

1

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

1983

1

);

1984

1

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

1985

1986

1

            let key_mapping_session_3 = AuthorityAssignment::collator_container_chain(3);

1987

1

            assert!(key_mapping_session_3.is_none());

1988

1989

            // Everything should match to aura

1990

1

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

1991

1992

1

            run_to_session(2u32);

1993

1

1994

1

            // Session 1 got removed

1995

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1);

1996

1

            assert!(key_mapping_session_1.is_none());

1997

1998

            // Session 2 uses the new keys

1999

1

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

2000

1

            assert_eq!(

2001

1

                key_mapping_session_2.orchestrator_chain,

2002

1

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

2003

1

);

2004

1

            assert_eq!(

2005

1

                old_assignment_session_1,

2006

1

                CollatorAssignment::collator_container_chain(),

2007

1

);

2008

2009

            // Session 3 uses the new keys

2010

1

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

2011

1

            assert_eq!(

2012

1

                key_mapping_session_3.orchestrator_chain,

2013

1

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

2014

1

);

2015

1

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

2016

2017

1

            let key_mapping_session_4 = AuthorityAssignment::collator_container_chain(4);

2018

1

            assert!(key_mapping_session_4.is_none());

2019

2020

            // Everything should match to aura

2021

1

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

2022

1

});

2023

1

2024

2025

2

fn call_transfer(

2026

2

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

2027

2

    value: u128,

2028

2

) -> RuntimeCall {

2029

2

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

2030

2

2031

2032

#[test]

2033

1

fn test_proxy_any() {

2034

1

    ExtBuilder::default()

2035

1

        .with_balances(vec![

2036

1

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

2037

1

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

2038

1

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

2039

1

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

2040

1

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

2041

1

])

2042

1

        .build()

2043

1

        .execute_with(|| {

2044

1

            run_to_block(2);

2045

1

2046

1

            let delay = 0;

2047

1

            assert_ok!(Proxy::add_proxy(

2048

1

                origin_of(ALICE.into()),

2049

1

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

2050

1

                ProxyType::Any,

2051

1

                delay

2052

1

));

2053

2054

1

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

2055

1

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

2056

1

            assert_ok!(Proxy::proxy(

2057

1

                origin_of(BOB.into()),

2058

1

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

2059

1

                None,

2060

1

                call

2061

1

));

2062

1

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

2063

1

2064

1

            assert_eq!(balance_after, balance_before + 200_000);

2065

1

});

2066

1

2067

2068

#[test]

2069

1

fn test_proxy_non_transfer() {

2070

1

    ExtBuilder::default()

2071

1

        .with_balances(vec![

2072

1

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

2073

1

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

2074

1

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

2075

1

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

2076

1

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

2077

1

])

2078

1

        .build()

2079

1

        .execute_with(|| {

2080

1

            run_to_block(2);

2081

1

2082

1

            let delay = 0;

2083

1

            assert_ok!(Proxy::add_proxy(

2084

1

                origin_of(ALICE.into()),

2085

1

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

2086

1

                ProxyType::NonTransfer,

2087

1

                delay

2088

1

));

2089

2090

1

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

2091

1

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

2092

1

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

2093

1

            assert_ok!(Proxy::proxy(

2094

1

                origin_of(BOB.into()),

2095

1

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

2096

1

                None,

2097

1

                call

2098

1

));

2099

1

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

2100

1

2101

1

            assert_eq!(balance_after, balance_before);

2102

1

});

2103

1

2104

2105

#[test]

2106

1

fn test_proxy_utility() {

2107

1

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

2108

1

    // subcalls don't allow to circumvent filters.

2109

1

2110

1

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

2111

1

    match ProxyType::Any {

2112

        ProxyType::Any

2113

        | ProxyType::NonTransfer

2114

        | ProxyType::Governance

2115

        | ProxyType::Staking

2116

        | ProxyType::CancelProxy

2117

        | ProxyType::Balances

2118

        | ProxyType::Registrar

2119

1

        | ProxyType::SudoRegistrar => (),

2120

1

};

2121

1

2122

1

    // All except for any

2123

1

    let proxy_types = &[

2124

1

        ProxyType::NonTransfer,

2125

1

        ProxyType::Governance,

2126

1

        ProxyType::Staking,

2127

1

        ProxyType::CancelProxy,

2128

1

        ProxyType::Balances,

2129

1

        ProxyType::Registrar,

2130

1

        ProxyType::SudoRegistrar,

2131

1

];

2132

2133

8

    for &proxy_type in proxy_types {

2134

7

        ExtBuilder::default()

2135

7

            .with_balances(vec![

2136

7

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

2137

7

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

2138

7

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

2139

7

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

2140

7

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

2141

7

])

2142

7

            .with_sudo(AccountId::from(ALICE))

2143

7

            .build()

2144

7

            .execute_with(|| {

2145

7

                assert_ok!(Proxy::add_proxy(

2146

7

                    origin_of(ALICE.into()),

2147

7

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

2148

7

                    proxy_type,

2149

7

2150

7

));

2151

2152

7

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

2153

7

2154

7

                assert_ok!(Proxy::proxy(

2155

7

                    origin_of(BOB.into()),

2156

7

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

2157

7

                    None,

2158

7

                    Box::new(

2159

7

                        pallet_sudo::Call::sudo {

2160

7

                            call: Box::new(

2161

7

                                pallet_utility::Call::batch {

2162

7

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

2163

7

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

2164

7

                                        new_free: 42424242424242

2165

7

2166

7

                                    .into()]

2167

7

2168

7

                                .into()

2169

7

2170

7

2171

7

                        .into()

2172

7

2173

7

));

2174

2175

7

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

2176

7

});

2177

7

2178

1

2179

2180

#[test]

2181

1

fn check_well_known_keys() {

2182

    use frame_support::traits::PalletInfo;

2183

2184

    // Pallet is named "Paras" in Polkadot.

2185

1

    assert_eq!(

2186

1

        well_known_keys::PARAS_HEADS_INDEX,

2187

1

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

2188

1

);

2189

2190

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

2191

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

2192

1

    assert_eq!(

2193

1

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

2194

1

        Some("AuthorityAssignment")

2195

1

);

2196

1

    assert_eq!(

2197

1

        well_known_keys::AUTHORITY_ASSIGNMENT_PREFIX,

2198

1

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

2199

1

);

2200

2201

1

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

2202

1

    assert_eq!(

2203

1

        well_known_keys::SESSION_INDEX,

2204

1

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

2205

1

);

2206

1

2207

2208

#[test]

2209

1

fn test_reward_to_invulnerable() {

2210

1

    // Alice, Bob, Charlie are invulnerables

2211

1

    ExtBuilder::default()

2212

1

        .with_balances(vec![

2213

1

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

2214

1

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

2215

1

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

2216

1

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

2217

1

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

2218

1

])

2219

1

        .with_collators(vec![

2220

1

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

2221

1

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

2222

1

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

2223

1

])

2224

1

        .with_empty_parachains(vec![1001, 1002])

2225

1

        .build()

2226

1

        .execute_with(|| {

2227

1

            run_to_block(2);

2228

1

2229

1

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

2230

1

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

2231

1

            // rewards.

2232

1

2233

1

            // wait for next session so that ALICE is elected

2234

1

            run_to_session(4u32);

2235

1

2236

1

            let account: AccountId = ALICE.into();

2237

1

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

2238

1

2239

1

            let summary = (0..100)

2240

2

                .find_map(|_| {

2241

2

                    let summary = run_block();

2242

2

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

2243

1

                        Some(summary)

2244

                    } else {

2245

1

                        None

2246

2247

2

})

2248

1

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

2249

1

2250

1

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

2251

1

2252

1

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

2253

1

            // rewards are shared between orchestrator and registered paras

2254

1

            let orchestrator_rewards = all_rewards / 3;

2255

1

            assert_eq!(

2256

1

                orchestrator_rewards,

2257

1

                balance_after - balance_before,

2258

                "alice should get the correct reward portion"

2259

);

2260

1

});

2261

1

2262

2263

#[test]

2264

1

fn test_reward_to_invulnerable_with_key_change() {

2265

1

    ExtBuilder::default()

2266

1

        .with_balances(vec![

2267

1

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

2268

1

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

2269

1

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

2270

1

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

2271

1

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

2272

1

])

2273

1

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

2274

1

        .with_empty_parachains(vec![1001, 1002])

2275

1

        .build()

2276

1

        .execute_with(|| {

2277

1

            run_to_block(2);

2278

1

2279

1

            run_to_session(2u32);

2280

1

2281

1

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

2282

1

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

2283

1

            assert_ok!(Session::set_keys(

2284

1

                origin_of(ALICE.into()),

2285

1

                crate::SessionKeys {

2286

1

                    nimbus: alice_new_key,

2287

1

},

2288

1

                vec![]

2289

1

));

2290

2291

1

            run_to_session(4u32);

2292

1

2293

1

            let account: AccountId = ALICE.into();

2294

1

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

2295

1

2296

1

            let summary = run_block();

2297

1

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

2298

2299

1

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

2300

1

2301

1

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

2302

1

            // rewards are shared between orchestrator and registered paras

2303

1

            let orchestrator_rewards = all_rewards / 3;

2304

1

            assert_eq!(

2305

1

                orchestrator_rewards,

2306

1

                balance_after - balance_before,

2307

                "alice should get the correct reward portion"

2308

);

2309

1

});

2310

1

2311

2312

#[test]

2313

1

fn test_can_buy_credits_before_registering_para() {

2314

1

    ExtBuilder::default()

2315

1

        .with_balances(vec![

2316

1

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

2317

1

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

2318

1

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

2319

1

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

2320

1

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

2321

1

])

2322

1

        .with_collators(vec![

2323

1

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

2324

1

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

2325

1

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

2326

1

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

2327

1

])

2328

1

        .build()

2329

1

        .execute_with(|| {

2330

1

            run_to_block(2);

2331

1

2332

1

            // Try to buy the maximum amount of credits

2333

1

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

2334

1

            assert_ok!(ServicesPayment::purchase_credits(

2335

1

                origin_of(ALICE.into()),

2336

1

                1001.into(),

2337

1

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

2338

1

));

2339

1

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

2340

1

2341

1

            // Now parachain tank should have this amount

2342

1

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

2343

1

                .data

2344

1

                .free;

2345

1

2346

1

            assert_eq!(

2347

1

                balance_tank,

2348

1

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

2349

1

);

2350

2351

1

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

2352

1

            assert_eq!(balance_before - balance_after, expected_cost);

2353

1

});

2354

1

2355

2356

#[test]

2357

1

fn test_cannot_mark_valid_para_with_no_bootnodes() {

2358

1

    ExtBuilder::default()

2359

1

        .with_balances(vec![

2360

1

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

2361

1

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

2362

1

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

2363

1

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

2364

1

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

2365

1

])

2366

1

        .with_collators(vec![

2367

1

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

2368

1

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

2369

1

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

2370

1

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

2371

1

])

2372

1

        .build()

2373

1

        .execute_with(|| {

2374

1

            run_to_block(2);

2375

1

            assert_ok!(Registrar::register(

2376

1

                origin_of(ALICE.into()),

2377

1

                1001.into(),

2378

1

                empty_genesis_data(),

2379

1

                None

2380

1

));

2381

1

            assert_noop!(

2382

1

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

2383

1

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

2384

1

);

2385

1

});

2386

1

2387

2388

#[test]

2389

1

fn test_can_buy_credits_before_registering_para_and_receive_free_credits() {

2390

1

    ExtBuilder::default()

2391

1

        .with_balances(vec![

2392

1

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

2393

1

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

2394

1

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

2395

1

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

2396

1

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

2397

1

])

2398

1

        .with_collators(vec![

2399

1

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

2400

1

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

2401

1

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

2402

1

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

2403

1

])

2404

1

        .build()

2405

1

        .execute_with(|| {

2406

1

            run_to_block(2);

2407

1

2408

1

            // Try to buy (FreeBlockProductionCredits - 1) credits

2409

1

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

2410

1

            assert_ok!(ServicesPayment::purchase_credits(

2411

1

                origin_of(ALICE.into()),

2412

1

                1001.into(),

2413

1

                block_credits_to_required_balance(

2414

1

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

2415

1

                    1001.into()

2416

1

2417

1

));

2418

1

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

2419

1

2420

1

            // Now parachain tank should have this amount

2421

1

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

2422

1

                .data

2423

1

                .free;

2424

1

2425

1

            assert_eq!(

2426

1

                balance_tank,

2427

1

                block_credits_to_required_balance(

2428

1

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

2429

1

                    1001.into()

2430

1

2431

1

);

2432

2433

1

            let expected_cost = block_credits_to_required_balance(

2434

1

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

2435

1

                1001.into(),

2436

1

);

2437

1

            assert_eq!(balance_before - balance_after, expected_cost);

2438

2439

            // Now register para

2440

1

            assert_ok!(Registrar::register(

2441

1

                origin_of(ALICE.into()),

2442

1

                1001.into(),

2443

1

                empty_genesis_data(),

2444

1

                None

2445

1

));

2446

1

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

2447

1

            assert_ok!(Registrar::mark_valid_for_collating(

2448

1

                root_origin(),

2449

1

                1001.into()

2450

1

));

2451

2452

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

2453

1

            let credits =

2454

1

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

2455

1

                    .unwrap_or_default();

2456

1

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

2457

1

});

2458

1

2459

2460

#[test]

2461

1

fn test_deregister_and_register_again_does_not_give_free_credits() {

2462

1

    ExtBuilder::default()

2463

1

        .with_balances(vec![

2464

1

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

2465

1

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

2466

1

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

2467

1

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

2468

1

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

2469

1

])

2470

1

        .with_collators(vec![

2471

1

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

2472

1

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

2473

1

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

2474

1

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

2475

1

])

2476

1

        .build()

2477

1

        .execute_with(|| {

2478

1

            run_to_block(2);

2479

1

2480

1

            // Register

2481

1

            assert_ok!(Registrar::register(

2482

1

                origin_of(ALICE.into()),

2483

1

                1001.into(),

2484

1

                empty_genesis_data(),

2485

1

                None

2486

1

            ),);

2487

1

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

2488

1

            assert_ok!(Registrar::mark_valid_for_collating(

2489

1

                root_origin(),

2490

1

                1001.into()

2491

1

            ),);

2492

            // We received free credits

2493

1

            let credits =

2494

1

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

2495

1

                    .unwrap_or_default();

2496

1

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

2497

            // Deregister after 1 session

2498

1

            run_to_session(1);

2499

1

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

2500

2501

1

            run_to_session(3);

2502

1

            let credits_before_2nd_register =

2503

1

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

2504

1

                    .unwrap_or_default();

2505

1

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

2506

1

            assert_ne!(

2507

1

                credits_before_2nd_register,

2508

1

                crate::FreeBlockProductionCredits::get()

2509

1

);

2510

            // Register again

2511

1

            assert_ok!(Registrar::register(

2512

1

                origin_of(ALICE.into()),

2513

1

                1001.into(),

2514

1

                empty_genesis_data(),

2515

1

                None

2516

1

            ),);

2517

1

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

2518

1

            assert_ok!(Registrar::mark_valid_for_collating(

2519

1

                root_origin(),

2520

1

                1001.into()

2521

1

            ),);

2522

            // No more free credits

2523

1

            let credits =

2524

1

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

2525

1

                    .unwrap_or_default();

2526

1

            assert_eq!(credits, credits_before_2nd_register);

2527

1

});

2528

1

2529

2530

#[test]

2531

1

fn test_register_parathread_not_allowed() {

2532

1

    ExtBuilder::default()

2533

1

        .with_balances(vec![

2534

1

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

2535

1

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

2536

1

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

2537

1

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

2538

1

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

2539

1

])

2540

1

        .with_collators(vec![

2541

1

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

2542

1

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

2543

1

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

2544

1

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

2545

1

])

2546

1

        .build()

2547

1

        .execute_with(|| {

2548

1

            run_to_block(2);

2549

1

2550

1

            assert_noop!(

2551

1

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

2552

1

                    para_id: 3001.into(),

2553

1

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

2554

1

                    genesis_data: empty_genesis_data(),

2555

1

                    head_data: None

2556

1

})

2557

1

                .dispatch(

2558

1

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

2559

1

                        ALICE

2560

1

))

2561

1

),

2562

1

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

2563

1

);

2564

1

});

2565

1

2566

2567

#[test]

2568

1

fn test_register_parathread_genesis() {

2569

1

    let parathread_params = tp_traits::ParathreadParams {

2570

1

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

2571

1

};

2572

1

    ExtBuilder::default()

2573

1

        .with_balances(vec![

2574

1

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

2575

1

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

2576

1

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

2577

1

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

2578

1

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

2579

1

])

2580

1

        .with_collators(vec![

2581

1

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

2582

1

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

2583

1

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

2584

1

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

2585

1

])

2586

1

        .with_para_ids(vec![ParaRegistrationParams {

2587

1

            para_id: 3001,

2588

1

            genesis_data: empty_genesis_data(),

2589

1

            block_production_credits: u32::MAX,

2590

1

            collator_assignment_credits: u32::MAX,

2591

1

            parathread_params: Some(parathread_params.clone()),

2592

1

}])

2593

1

        .build()

2594

1

        .execute_with(|| {

2595

1

            run_to_block(2);

2596

1

2597

1

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

2598

1

            assert_eq!(

2599

1

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

2600

1

                Some(parathread_params)

2601

1

);

2602

2603

1

            let assignment = CollatorAssignment::collator_container_chain();

2604

1

            assert_eq!(

2605

1

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

2606

1

                vec![CHARLIE.into()]

2607

1

);

2608

1

});

2609

1

2610

2611

#[test]

2612

1

fn test_ed_plus_block_credit_session_purchase_works() {

2613

1

    ExtBuilder::default()

2614

1

        .with_balances(vec![

2615

1

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

2616

1

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

2617

1

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

2618

1

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

2619

1

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

2620

1

])

2621

1

        .with_collators(vec![

2622

1

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

2623

1

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

2624

1

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

2625

1

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

2626

1

])

2627

1

        .build()

2628

1

        .execute_with(|| {

2629

1

            run_to_block(2);

2630

1

            // Assert current slot gets updated

2631

1

            assert_eq!(current_slot(), 1u64);

2632

1

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

2633

2634

            // Alice and Bob collate in our chain

2635

1

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

2636

1

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

2637

1

2638

1

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

2639

2640

1

            assert_ok!(Registrar::register(

2641

1

                origin_of(ALICE.into()),

2642

1

                1001.into(),

2643

1

                empty_genesis_data(),

2644

1

                None

2645

1

));

2646

1

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

2647

1

            assert_ok!(Registrar::mark_valid_for_collating(

2648

1

                root_origin(),

2649

1

                1001.into()

2650

1

));

2651

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

2652

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2653

1

                root_origin(),

2654

1

                1001.into(),

2655

1

2656

1

));

2657

1

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

2658

1

                + crate::EXISTENTIAL_DEPOSIT;

2659

1

2660

1

            // Fill the tank

2661

1

            assert_ok!(ServicesPayment::purchase_credits(

2662

1

                origin_of(ALICE.into()),

2663

1

                1001.into(),

2664

1

                credits_1001

2665

1

));

2666

2667

            // Assignment should happen after 2 sessions

2668

1

            run_to_session(1u32);

2669

1

            let assignment = CollatorAssignment::collator_container_chain();

2670

1

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

2671

1

            run_to_session(2u32);

2672

1

            // Charlie and Dave should be assigned to para 1001

2673

1

            let assignment = CollatorAssignment::collator_container_chain();

2674

1

            assert_eq!(

2675

1

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

2676

1

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

2677

1

);

2678

2679

            // Simulate block inclusion from container chain 1001

2680

1

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

2681

1

            let slot: u64 = 5;

2682

1

            let s = ParaHeaderSproofBuilderItem {

2683

1

                para_id: 1001.into(),

2684

1

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

2685

1

                    parent_hash: Default::default(),

2686

1

                    number: 1,

2687

1

                    state_root: Default::default(),

2688

1

                    extrinsics_root: Default::default(),

2689

1

                    digest: sp_runtime::generic::Digest {

2690

1

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

2691

1

},

2692

1

}),

2693

1

};

2694

1

2695

1

            sproof.items.push(s);

2696

1

            set_author_noting_inherent_data(sproof);

2697

1

2698

1

            run_block();

2699

1

2700

1

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

2701

1

            run_to_session(3u32);

2702

1

            // Nobody should be assigned to para 1001

2703

1

            let assignment = CollatorAssignment::collator_container_chain();

2704

1

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

2705

1

});

2706

1

2707

2708

#[test]

2709

1

fn test_ed_plus_block_credit_session_minus_1_purchase_fails() {

2710

1

    ExtBuilder::default()

2711

1

        .with_balances(vec![

2712

1

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

2713

1

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

2714

1

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

2715

1

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

2716

1

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

2717

1

])

2718

1

        .with_collators(vec![

2719

1

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

2720

1

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

2721

1

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

2722

1

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

2723

1

])

2724

1

        .build()

2725

1

        .execute_with(|| {

2726

1

            run_to_block(2);

2727

1

            // Assert current slot gets updated

2728

1

            assert_eq!(current_slot(), 1u64);

2729

1

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

2730

2731

            // Alice and Bob collate in our chain

2732

1

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

2733

1

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

2734

1

2735

1

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

2736

2737

1

            assert_ok!(Registrar::register(

2738

1

                origin_of(ALICE.into()),

2739

1

                1001.into(),

2740

1

                empty_genesis_data(),

2741

1

                None

2742

1

));

2743

1

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

2744

1

            assert_ok!(Registrar::mark_valid_for_collating(

2745

1

                root_origin(),

2746

1

                1001.into()

2747

1

));

2748

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

2749

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2750

1

                root_origin(),

2751

1

                1001.into(),

2752

1

2753

1

));

2754

1

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

2755

1

                + crate::EXISTENTIAL_DEPOSIT

2756

1

                - 1;

2757

1

2758

1

            // Fill the tank

2759

1

            assert_ok!(ServicesPayment::purchase_credits(

2760

1

                origin_of(ALICE.into()),

2761

1

                1001.into(),

2762

1

                credits_1001

2763

1

));

2764

2765

            // Assignment should happen after 2 sessions

2766

1

            run_to_session(1u32);

2767

1

            let assignment = CollatorAssignment::collator_container_chain();

2768

1

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

2769

1

            run_to_session(2u32);

2770

1

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

2771

1

            let assignment = CollatorAssignment::collator_container_chain();

2772

1

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

2773

1

});

2774

1

2775

2776

#[test]

2777

1

fn test_reassignment_ed_plus_two_block_credit_session_purchase_works() {

2778

1

    ExtBuilder::default()

2779

1

        .with_balances(vec![

2780

1

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

2781

1

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

2782

1

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

2783

1

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

2784

1

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

2785

1

])

2786

1

        .with_collators(vec![

2787

1

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

2788

1

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

2789

1

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

2790

1

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

2791

1

])

2792

1

        .build()

2793

1

        .execute_with(|| {

2794

1

            run_to_block(2);

2795

1

            // Assert current slot gets updated

2796

1

            assert_eq!(current_slot(), 1u64);

2797

1

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

2798

2799

            // Alice and Bob collate in our chain

2800

1

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

2801

1

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

2802

1

2803

1

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

2804

2805

1

            assert_ok!(Registrar::register(

2806

1

                origin_of(ALICE.into()),

2807

1

                1001.into(),

2808

1

                empty_genesis_data(),

2809

1

                None

2810

1

));

2811

1

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

2812

1

            assert_ok!(Registrar::mark_valid_for_collating(

2813

1

                root_origin(),

2814

1

                1001.into()

2815

1

));

2816

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

2817

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2818

1

                root_origin(),

2819

1

                1001.into(),

2820

1

2821

1

));

2822

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

2823

1

            let credits_1001 =

2824

1

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

2825

1

                    + crate::EXISTENTIAL_DEPOSIT;

2826

1

2827

1

            // Fill the tank

2828

1

            assert_ok!(ServicesPayment::purchase_credits(

2829

1

                origin_of(ALICE.into()),

2830

1

                1001.into(),

2831

1

                credits_1001

2832

1

));

2833

2834

            // Assignment should happen after 2 sessions

2835

1

            run_to_session(1u32);

2836

1

            let assignment = CollatorAssignment::collator_container_chain();

2837

1

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

2838

2839

1

            run_to_session(2u32);

2840

1

            // Charlie and Dave should be assigned to para 1001

2841

1

            let assignment = CollatorAssignment::collator_container_chain();

2842

1

            assert_eq!(

2843

1

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

2844

1

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

2845

1

);

2846

2847

            // Simulate block inclusion from container chain 1001

2848

1

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

2849

1

            let slot: u64 = 5;

2850

1

            let s = ParaHeaderSproofBuilderItem {

2851

1

                para_id: 1001.into(),

2852

1

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

2853

1

                    parent_hash: Default::default(),

2854

1

                    number: 1,

2855

1

                    state_root: Default::default(),

2856

1

                    extrinsics_root: Default::default(),

2857

1

                    digest: sp_runtime::generic::Digest {

2858

1

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

2859

1

},

2860

1

}),

2861

1

};

2862

1

2863

1

            sproof.items.push(s);

2864

1

            set_author_noting_inherent_data(sproof);

2865

1

2866

1

            run_block();

2867

1

2868

1

            // Session 3 should still be assigned

2869

1

            run_to_session(3u32);

2870

1

            // Charlie and Dave should be assigned to para 1001

2871

1

            let assignment = CollatorAssignment::collator_container_chain();

2872

1

            assert_eq!(

2873

1

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

2874

1

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

2875

1

);

2876

2877

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

2878

1

            run_to_session(4u32);

2879

1

            // Nobody should be assigned to para 1001

2880

1

            let assignment = CollatorAssignment::collator_container_chain();

2881

1

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

2882

1

});

2883

1

2884

2885

#[test]

2886

1

fn test_reassignment_ed_plus_two_block_credit_session_minus_1_purchase_fails() {

2887

1

    ExtBuilder::default()

2888

1

        .with_balances(vec![

2889

1

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

2890

1

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

2891

1

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

2892

1

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

2893

1

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

2894

1

])

2895

1

        .with_collators(vec![

2896

1

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

2897

1

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

2898

1

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

2899

1

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

2900

1

])

2901

1

        .build()

2902

1

        .execute_with(|| {

2903

1

            run_to_block(2);

2904

1

            // Assert current slot gets updated

2905

1

            assert_eq!(current_slot(), 1u64);

2906

1

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

2907

2908

            // Alice and Bob collate in our chain

2909

1

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

2910

1

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

2911

1

2912

1

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

2913

2914

1

            assert_ok!(Registrar::register(

2915

1

                origin_of(ALICE.into()),

2916

1

                1001.into(),

2917

1

                empty_genesis_data(),

2918

1

                None

2919

1

));

2920

1

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

2921

1

            assert_ok!(Registrar::mark_valid_for_collating(

2922

1

                root_origin(),

2923

1

                1001.into()

2924

1

));

2925

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

2926

1

            assert_ok!(ServicesPayment::set_block_production_credits(

2927

1

                root_origin(),

2928

1

                1001.into(),

2929

1

2930

1

));

2931

1

            let credits_1001 =

2932

1

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

2933

1

                    + crate::EXISTENTIAL_DEPOSIT

2934

1

                    - 1;

2935

1

2936

1

            // Fill the tank

2937

1

            assert_ok!(ServicesPayment::purchase_credits(

2938

1

                origin_of(ALICE.into()),

2939

1

                1001.into(),

2940

1

                credits_1001

2941

1

));

2942

2943

            // Assignment should happen after 2 sessions

2944

1

            run_to_session(1u32);

2945

1

            let assignment = CollatorAssignment::collator_container_chain();

2946

1

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

2947

2948

1

            run_to_session(2u32);

2949

1

            // Charlie and Dave should be assigned to para 1001

2950

1

            let assignment = CollatorAssignment::collator_container_chain();

2951

1

            assert_eq!(

2952

1

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

2953

1

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

2954

1

);

2955

2956

            // Simulate block inclusion from container chain 1001

2957

1

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

2958

1

            let slot: u64 = 5;

2959

1

            let s = ParaHeaderSproofBuilderItem {

2960

1

                para_id: 1001.into(),

2961

1

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

2962

1

                    parent_hash: Default::default(),

2963

1

                    number: 1,

2964

1

                    state_root: Default::default(),

2965

1

                    extrinsics_root: Default::default(),

2966

1

                    digest: sp_runtime::generic::Digest {

2967

1

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

2968

1

},

2969

1

}),

2970

1

};

2971

1

2972

1

            sproof.items.push(s);

2973

1

            set_author_noting_inherent_data(sproof);

2974

1

2975

1

            run_block();

2976

1

2977

1

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

2978

1

            run_to_session(3u32);

2979

1

            // Nobody should be assigned to para 1001

2980

1

            let assignment = CollatorAssignment::collator_container_chain();

2981

1

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

2982

1

});

2983

1

2984

2985

#[test]

2986

1

fn test_credits_with_purchase_can_be_combined() {

2987

1

    ExtBuilder::default()

2988

1

        .with_balances(vec![

2989

1

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

2990

1

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

2991

1

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

2992

1

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

2993

1

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

2994

1

])

2995

1

        .with_collators(vec![

2996

1

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

2997

1

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

2998

1

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

2999

1

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

3000

1

])

3001

1

        .build()

3002

1

        .execute_with(|| {

3003

1

            run_to_block(2);

3004

1

            // Assert current slot gets updated

3005

1

            assert_eq!(current_slot(), 1u64);

3006

1

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

3007

3008

            // Alice and Bob collate in our chain

3009

1

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

3010

1

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

3011

1

3012

1

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

3013

3014

1

            assert_ok!(Registrar::register(

3015

1

                origin_of(ALICE.into()),

3016

1

                1001.into(),

3017

1

                empty_genesis_data(),

3018

1

                None

3019

1

));

3020

1

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

3021

1

            assert_ok!(Registrar::mark_valid_for_collating(

3022

1

                root_origin(),

3023

1

                1001.into()

3024

1

));

3025

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

3026

1

            assert_ok!(ServicesPayment::set_block_production_credits(

3027

1

                root_origin(),

3028

1

                1001.into(),

3029

1

                crate::Period::get()

3030

1

));

3031

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

3032

1

                + crate::EXISTENTIAL_DEPOSIT;

3033

1

3034

1

            // Fill the tank

3035

1

            assert_ok!(ServicesPayment::purchase_credits(

3036

1

                origin_of(ALICE.into()),

3037

1

                1001.into(),

3038

1

                credits_1001

3039

1

));

3040

3041

            // Assignment should happen after 2 sessions

3042

1

            run_to_session(1u32);

3043

1

            let assignment = CollatorAssignment::collator_container_chain();

3044

1

            assert!(assignment.container_chains.is_empty());

3045

1

            run_to_session(2u32);

3046

1

            // Charlie and Dave should be assigned to para 1001

3047

1

            let assignment = CollatorAssignment::collator_container_chain();

3048

1

            assert_eq!(

3049

1

                assignment.container_chains[&1001u32.into()],

3050

1

                vec![CHARLIE.into(), DAVE.into()]

3051

1

);

3052

1

});

3053

1

3054

#[test]

3055

1

fn stream_payment_works() {

3056

1

    ExtBuilder::default()

3057

1

        .with_balances(vec![

3058

1

            (AccountId::from(ALICE), 100_000 * UNIT),

3059

1

            (AccountId::from(BOB), 100_000 * UNIT),

3060

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3061

1

])

3062

1

        .with_collators(vec![

3063

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3064

1

            (AccountId::from(DAVE), 100 * UNIT),

3065

1

])

3066

1

        .build()

3067

1

        .execute_with(|| {

3068

            use pallet_stream_payment::{ChangeKind, StreamConfig};

3069

3070

1

            assert_ok!(StreamPayment::open_stream(

3071

1

                origin_of(ALICE.into()),

3072

1

                BOB.into(),

3073

1

                StreamConfig {

3074

1

                    rate: 2 * UNIT,

3075

1

                    asset_id: StreamPaymentAssetId::Native,

3076

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

3077

1

                    minimum_request_deadline_delay: 0,

3078

1

                    soft_minimum_deposit: 0,

3079

1

},

3080

1

                1_000 * UNIT,

3081

1

));

3082

3083

1

            run_block();

3084

1

3085

1

            assert_ok!(StreamPayment::perform_payment(origin_of(CHARLIE.into()), 0));

3086

1

            assert_eq!(

3087

1

                Balances::free_balance(AccountId::from(BOB)),

3088

1

                100_000 * UNIT + 2 * UNIT

3089

1

);

3090

3091

1

            assert_ok!(StreamPayment::request_change(

3092

1

                origin_of(ALICE.into()),

3093

1

0,

3094

1

                ChangeKind::Suggestion,

3095

1

                StreamConfig {

3096

1

                    rate: 1 * UNIT,

3097

1

                    asset_id: StreamPaymentAssetId::Native,

3098

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

3099

1

                    minimum_request_deadline_delay: 0,

3100

1

                    soft_minimum_deposit: 0,

3101

1

},

3102

1

                None,

3103

1

));

3104

3105

1

            assert_ok!(StreamPayment::accept_requested_change(

3106

1

                origin_of(BOB.into()),

3107

1

0,

3108

1

                1, // nonce

3109

1

                None,

3110

1

));

3111

3112

1

            run_block();

3113

1

3114

1

            assert_ok!(StreamPayment::close_stream(origin_of(BOB.into()), 0));

3115

3116

1

            assert_eq!(

3117

1

                Balances::free_balance(AccountId::from(BOB)),

3118

1

                100_000 * UNIT + 3 * UNIT

3119

1

);

3120

1

            assert_eq!(

3121

1

                Balances::free_balance(AccountId::from(ALICE)),

3122

1

                100_000 * UNIT - 3 * UNIT

3123

1

);

3124

1

});

3125

1

3126

3127

#[test]

3128

1

fn test_ed_plus_collator_assignment_session_purchase_works() {

3129

1

    ExtBuilder::default()

3130

1

        .with_balances(vec![

3131

1

            // Alice gets 10k extra tokens for her mapping deposit

3132

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3133

1

            (AccountId::from(BOB), 100_000 * UNIT),

3134

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3135

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3136

1

])

3137

1

        .with_collators(vec![

3138

1

            (AccountId::from(ALICE), 210 * UNIT),

3139

1

            (AccountId::from(BOB), 100 * UNIT),

3140

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3141

1

            (AccountId::from(DAVE), 100 * UNIT),

3142

1

])

3143

1

        .build()

3144

1

        .execute_with(|| {

3145

1

            run_to_block(2);

3146

1

            // Assert current slot gets updated

3147

1

            assert_eq!(current_slot(), 1u64);

3148

1

            assert!(current_author() == AccountId::from(BOB));

3149

3150

            // Alice and Bob collate in our chain

3151

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3152

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3153

1

3154

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3155

3156

1

            assert_ok!(Registrar::register(

3157

1

                origin_of(ALICE.into()),

3158

1

                1001.into(),

3159

1

                empty_genesis_data(),

3160

1

                None

3161

1

));

3162

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3163

1

            assert_ok!(Registrar::mark_valid_for_collating(

3164

1

                root_origin(),

3165

1

                1001.into()

3166

1

));

3167

            // Need to reset credits to 0 because now parachains are given free credits on register

3168

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3169

1

                root_origin(),

3170

1

                1001.into(),

3171

1

3172

1

));

3173

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3174

1

                + crate::EXISTENTIAL_DEPOSIT;

3175

1

3176

1

            // Fill the tank

3177

1

            assert_ok!(ServicesPayment::purchase_credits(

3178

1

                origin_of(ALICE.into()),

3179

1

                1001.into(),

3180

1

                credits_1001

3181

1

));

3182

3183

            // Assignment should happen after 2 sessions

3184

1

            run_to_session(1u32);

3185

1

            let assignment = CollatorAssignment::collator_container_chain();

3186

1

            assert!(assignment.container_chains.is_empty());

3187

1

            run_to_session(2u32);

3188

1

            // Charlie and Dave should be assigned to para 1001

3189

1

            let assignment = CollatorAssignment::collator_container_chain();

3190

1

            assert_eq!(

3191

1

                assignment.container_chains[&1001u32.into()],

3192

1

                vec![CHARLIE.into(), DAVE.into()]

3193

1

);

3194

3195

            // Simulate block inclusion from container chain 1001

3196

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

3197

1

            let slot: u64 = 5;

3198

1

            let s = ParaHeaderSproofBuilderItem {

3199

1

                para_id: 1001.into(),

3200

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

3201

1

                    parent_hash: Default::default(),

3202

1

                    number: 1,

3203

1

                    state_root: Default::default(),

3204

1

                    extrinsics_root: Default::default(),

3205

1

                    digest: sp_runtime::generic::Digest {

3206

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

3207

1

},

3208

1

}),

3209

1

};

3210

1

            sproof.items.push(s);

3211

1

            set_author_noting_inherent_data(sproof);

3212

1

3213

1

            run_block();

3214

1

3215

1

            // After this it should not be assigned anymore, since credits are not payable

3216

1

            run_to_session(4u32);

3217

1

            // Nobody should be assigned to para 1001

3218

1

            let assignment = CollatorAssignment::collator_container_chain();

3219

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

3220

1

});

3221

1

3222

3223

#[test]

3224

1

fn test_ed_plus_collator_assignment_credit_session_minus_1_purchase_fails() {

3225

1

    ExtBuilder::default()

3226

1

        .with_balances(vec![

3227

1

            // Alice gets 10k extra tokens for her mapping deposit

3228

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3229

1

            (AccountId::from(BOB), 100_000 * UNIT),

3230

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3231

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3232

1

])

3233

1

        .with_collators(vec![

3234

1

            (AccountId::from(ALICE), 210 * UNIT),

3235

1

            (AccountId::from(BOB), 100 * UNIT),

3236

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3237

1

            (AccountId::from(DAVE), 100 * UNIT),

3238

1

])

3239

1

        .build()

3240

1

        .execute_with(|| {

3241

1

            run_to_block(2);

3242

1

            // Assert current slot gets updated

3243

1

            assert_eq!(current_slot(), 1u64);

3244

1

            assert!(current_author() == AccountId::from(BOB));

3245

3246

            // Alice and Bob collate in our chain

3247

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3248

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3249

1

3250

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3251

3252

1

            assert_ok!(Registrar::register(

3253

1

                origin_of(ALICE.into()),

3254

1

                1001.into(),

3255

1

                empty_genesis_data(),

3256

1

                None

3257

1

));

3258

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3259

1

            assert_ok!(Registrar::mark_valid_for_collating(

3260

1

                root_origin(),

3261

1

                1001.into()

3262

1

));

3263

            // Need to reset credits to 0 because now parachains are given free credits on register

3264

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3265

1

                root_origin(),

3266

1

                1001.into(),

3267

1

3268

1

));

3269

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3270

1

                + crate::EXISTENTIAL_DEPOSIT

3271

1

                - 1;

3272

1

3273

1

            // Fill the tank

3274

1

            assert_ok!(ServicesPayment::purchase_credits(

3275

1

                origin_of(ALICE.into()),

3276

1

                1001.into(),

3277

1

                credits_1001

3278

1

));

3279

3280

            // Assignment should happen after 2 sessions

3281

1

            run_to_session(1u32);

3282

1

            let assignment = CollatorAssignment::collator_container_chain();

3283

1

            assert!(assignment.container_chains.is_empty());

3284

1

            run_to_session(2u32);

3285

1

            // Charlie and Dave should not be assigned to para 1001

3286

1

            let assignment = CollatorAssignment::collator_container_chain();

3287

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

3288

1

});

3289

1

3290

3291

#[test]

3292

1

fn test_collator_assignment_credits_with_purchase_can_be_combined() {

3293

1

    ExtBuilder::default()

3294

1

        .with_balances(vec![

3295

1

            // Alice gets 10k extra tokens for her mapping deposit

3296

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3297

1

            (AccountId::from(BOB), 100_000 * UNIT),

3298

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3299

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3300

1

])

3301

1

        .with_collators(vec![

3302

1

            (AccountId::from(ALICE), 210 * UNIT),

3303

1

            (AccountId::from(BOB), 100 * UNIT),

3304

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3305

1

            (AccountId::from(DAVE), 100 * UNIT),

3306

1

])

3307

1

        .build()

3308

1

        .execute_with(|| {

3309

1

            run_to_block(2);

3310

1

            // Assert current slot gets updated

3311

1

            assert_eq!(current_slot(), 1u64);

3312

1

            assert!(current_author() == AccountId::from(BOB));

3313

3314

            // Alice and Bob collate in our chain

3315

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3316

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3317

1

3318

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3319

3320

1

            assert_ok!(Registrar::register(

3321

1

                origin_of(ALICE.into()),

3322

1

                1001.into(),

3323

1

                empty_genesis_data(),

3324

1

                None

3325

1

));

3326

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3327

1

            assert_ok!(Registrar::mark_valid_for_collating(

3328

1

                root_origin(),

3329

1

                1001.into()

3330

1

));

3331

3332

            // We assign one session to free credits

3333

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3334

1

                root_origin(),

3335

1

                1001.into(),

3336

1

3337

1

));

3338

            // We buy another session through the tank

3339

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

3340

1

                + crate::EXISTENTIAL_DEPOSIT;

3341

1

3342

1

            // Fill the tank

3343

1

            assert_ok!(ServicesPayment::purchase_credits(

3344

1

                origin_of(ALICE.into()),

3345

1

                1001.into(),

3346

1

                credits_1001

3347

1

));

3348

3349

            // Assignment should happen after 2 sessions

3350

1

            run_to_session(1u32);

3351

1

            let assignment = CollatorAssignment::collator_container_chain();

3352

1

            assert!(assignment.container_chains.is_empty());

3353

1

            run_to_session(2u32);

3354

1

            // Charlie and Dave should be assigned to para 1001

3355

1

            let assignment = CollatorAssignment::collator_container_chain();

3356

1

            assert_eq!(

3357

1

                assignment.container_chains[&1001u32.into()],

3358

1

                vec![CHARLIE.into(), DAVE.into()]

3359

1

);

3360

1

});

3361

1

3362

3363

#[test]

3364

1

fn test_block_credits_and_collator_assignation_credits_through_tank() {

3365

1

    ExtBuilder::default()

3366

1

        .with_balances(vec![

3367

1

            // Alice gets 10k extra tokens for her mapping deposit

3368

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3369

1

            (AccountId::from(BOB), 100_000 * UNIT),

3370

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3371

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3372

1

])

3373

1

        .with_collators(vec![

3374

1

            (AccountId::from(ALICE), 210 * UNIT),

3375

1

            (AccountId::from(BOB), 100 * UNIT),

3376

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3377

1

            (AccountId::from(DAVE), 100 * UNIT),

3378

1

])

3379

1

        .build()

3380

1

        .execute_with(|| {

3381

1

            run_to_block(2);

3382

1

            // Assert current slot gets updated

3383

1

            assert_eq!(current_slot(), 1u64);

3384

1

            assert!(current_author() == AccountId::from(BOB));

3385

3386

            // Alice and Bob collate in our chain

3387

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

3388

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3389

1

3390

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

3391

3392

1

            assert_ok!(Registrar::register(

3393

1

                origin_of(ALICE.into()),

3394

1

                1001.into(),

3395

1

                empty_genesis_data(),

3396

1

                None

3397

1

));

3398

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3399

1

            assert_ok!(Registrar::mark_valid_for_collating(

3400

1

                root_origin(),

3401

1

                1001.into()

3402

1

));

3403

3404

            // We make all free credits 0

3405

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

3406

1

                root_origin(),

3407

1

                1001.into(),

3408

1

3409

1

));

3410

1

            assert_ok!(ServicesPayment::set_block_production_credits(

3411

1

                root_origin(),

3412

1

                1001.into(),

3413

1

3414

1

));

3415

3416

            // We buy 2 sessions through tank

3417

1

            let collator_assignation_credits =

3418

1

                collator_assignment_credits_to_required_balance(2, 1001.into());

3419

1

            let block_production_credits =

3420

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into());

3421

1

3422

1

            // Fill the tank

3423

1

            assert_ok!(ServicesPayment::purchase_credits(

3424

1

                origin_of(ALICE.into()),

3425

1

                1001.into(),

3426

1

                collator_assignation_credits

3427

1

                    + block_production_credits

3428

1

                    + crate::EXISTENTIAL_DEPOSIT

3429

1

));

3430

3431

            // Assignment should happen after 2 sessions

3432

1

            run_to_session(1u32);

3433

1

            let assignment = CollatorAssignment::collator_container_chain();

3434

1

            assert!(assignment.container_chains.is_empty());

3435

1

            run_to_session(2u32);

3436

1

            // Charlie and Dave should be assigned to para 1001

3437

1

            let assignment = CollatorAssignment::collator_container_chain();

3438

1

            assert_eq!(

3439

1

                assignment.container_chains[&1001u32.into()],

3440

1

                vec![CHARLIE.into(), DAVE.into()]

3441

1

);

3442

3443

            // After this it should not be assigned anymore, since credits are not payable

3444

1

            run_to_session(4u32);

3445

1

            // Nobody should be assigned to para 1001

3446

1

            let assignment = CollatorAssignment::collator_container_chain();

3447

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

3448

1

});

3449

1

3450

3451

#[test]

3452

1

fn test_migration_services_collator_assignment_payment() {

3453

1

    ExtBuilder::default().build().execute_with(|| {

3454

1

        // Register a new parachain with no credits

3455

1

        assert_ok!(Registrar::register(

3456

1

            origin_of(ALICE.into()),

3457

1

            1001.into(),

3458

1

            empty_genesis_data(),

3459

1

            None

3460

1

));

3461

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

3462

1

        assert_ok!(Registrar::mark_valid_for_collating(

3463

1

            root_origin(),

3464

1

            1001.into()

3465

1

));

3466

        // Register another parachain with no credits, do not mark this as valid for collation

3467

1

        assert_ok!(Registrar::register(

3468

1

            origin_of(ALICE.into()),

3469

1

            1002.into(),

3470

1

            empty_genesis_data(),

3471

1

            None

3472

1

));

3473

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1002.into());

3474

1

        assert_ok!(Registrar::mark_valid_for_collating(

3475

1

            root_origin(),

3476

1

            1002.into()

3477

1

));

3478

3479

        // Need to reset credits to 0 because now parachains are given free credits on register

3480

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

3481

1

            root_origin(),

3482

1

            1001.into(),

3483

1

3484

1

));

3485

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

3486

1

            root_origin(),

3487

1

            1002.into(),

3488

1

3489

1

));

3490

3491

1

        let credits_1001 =

3492

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

3493

1

                .unwrap_or_default();

3494

1

        assert_eq!(credits_1001, 0);

3495

1

        let credits_1002 =

3496

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

3497

1

                .unwrap_or_default();

3498

1

        assert_eq!(credits_1002, 0);

3499

3500

        // Apply migration

3501

1

        let migration =

3502

1

            MigrateServicesPaymentAddCollatorAssignmentCredits::<Runtime>(Default::default());

3503

1

        migration.migrate(Default::default());

3504

1

3505

1

        // Both parachains have been given credits

3506

1

        let credits_1001 =

3507

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

3508

1

                .unwrap_or_default();

3509

1

        assert_eq!(credits_1001, crate::FreeCollatorAssignmentCredits::get());

3510

1

        let credits_1002 =

3511

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

3512

1

                .unwrap_or_default();

3513

1

        assert_eq!(credits_1002, crate::FreeCollatorAssignmentCredits::get());

3514

1

});

3515

1

3516

3517

#[test]

3518

1

fn test_max_collators_uses_pending_value() {

3519

1

    // Start with max_collators = 100, and collators_per_container = 2

3520

1

    // Set max_collators = 2, and collators_per_container = 3

3521

1

    // It should be impossible to have more than 2 collators per container at any point in time

3522

1

    ExtBuilder::default()

3523

1

        .with_balances(vec![

3524

1

            // Alice gets 10k extra tokens for her mapping deposit

3525

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3526

1

            (AccountId::from(BOB), 100_000 * UNIT),

3527

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3528

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3529

1

])

3530

1

        .with_collators(vec![

3531

1

            (AccountId::from(ALICE), 210 * UNIT),

3532

1

            (AccountId::from(BOB), 100 * UNIT),

3533

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3534

1

            (AccountId::from(DAVE), 100 * UNIT),

3535

1

])

3536

1

        .with_empty_parachains(vec![1001])

3537

1

        .with_config(pallet_configuration::HostConfiguration {

3538

1

            max_collators: 100,

3539

1

            min_orchestrator_collators: 1,

3540

1

            max_orchestrator_collators: 1,

3541

1

            collators_per_container: 2,

3542

1

            full_rotation_period: 24,

3543

1

            ..Default::default()

3544

1

})

3545

1

        .build()

3546

1

        .execute_with(|| {

3547

1

            run_to_block(2);

3548

1

3549

1

            // Initial assignment: 1 collator in orchestrator chain and 2 collators in container 1001

3550

1

            let assignment = CollatorAssignment::collator_container_chain();

3551

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 2);

3552

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

3553

3554

1

            assert_ok!(Configuration::set_max_collators(root_origin(), 2));

3555

1

            assert_ok!(Configuration::set_collators_per_container(root_origin(), 3));

3556

3557

            // Check invariant for all intermediate assignments. We set collators_per_container = 3

3558

            // but we also set max_collators = 2, so no collators will be assigned to container

3559

            // chains after the change is applied.

3560

5

            for session in 1..=4 {

3561

4

                run_to_session(session);

3562

4

3563

4

                let assignment = CollatorAssignment::collator_container_chain();

3564

4

                assert!(

3565

4

                    assignment.container_chains[&1001u32.into()].len() <= 2,

3566

                    "session {}: {} collators assigned to container chain 1001",

3567

                    session,

3568

                    assignment.container_chains[&1001u32.into()].len()

3569

);

3570

3571

3572

            // Final assignment: because max_collators = 2, there are only 2 collators, one in

3573

            // orchestrator chain, and the other one idle

3574

1

            let assignment = CollatorAssignment::collator_container_chain();

3575

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 0);

3576

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

3577

1

});

3578

1

3579

3580

#[test]

3581

1

fn test_slow_adjusting_multiplier_changes_in_response_to_consumed_weight() {

3582

1

    ExtBuilder::default()

3583

1

        .with_collators(vec![

3584

1

            (AccountId::from(ALICE), 210 * UNIT),

3585

1

            (AccountId::from(BOB), 100 * UNIT),

3586

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3587

1

            (AccountId::from(DAVE), 100 * UNIT),

3588

1

])

3589

1

        .build()

3590

1

        .execute_with(|| {

3591

1

            end_block();

3592

1

            // If the block is full, the multiplier increases

3593

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

3594

1

            start_block();

3595

1

            let max_block_weights = crate::RuntimeBlockWeights::get();

3596

1

            frame_support::storage::unhashed::put(

3597

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

3598

3

                &ConsumedWeight::new(|class| {

3599

3

                    max_block_weights

3600

3

                        .get(class)

3601

3

                        .max_total

3602

3

                        .unwrap_or(Weight::MAX)

3603

3

}),

3604

1

);

3605

1

            end_block();

3606

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

3607

1

            assert!(current_multiplier > before_multiplier);

3608

3609

            // If the block is empty, the multiplier decreases

3610

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

3611

1

            start_block();

3612

1

            frame_support::storage::unhashed::put(

3613

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

3614

3

                &ConsumedWeight::new(|_class| Weight::zero()),

3615

1

);

3616

1

            end_block();

3617

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

3618

1

            assert!(current_multiplier < before_multiplier);

3619

1

});

3620

1

3621

3622

#[test]

3623

1

fn test_collator_assignment_tip_priority_on_congestion() {

3624

1

    ExtBuilder::default()

3625

1

        .with_balances(vec![

3626

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3627

1

            (AccountId::from(BOB), 100_000 * UNIT),

3628

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3629

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3630

1

])

3631

1

        .with_collators(vec![

3632

1

            (AccountId::from(ALICE), 210 * UNIT),

3633

1

            (AccountId::from(BOB), 100 * UNIT),

3634

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3635

1

            (AccountId::from(DAVE), 100 * UNIT),

3636

1

])

3637

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3638

1

        .build()

3639

1

        .execute_with(|| {

3640

1

            let para_id = 1003u32;

3641

1

            let tank_funds = 100 * UNIT;

3642

1

            let max_tip = 1 * UNIT;

3643

1

3644

1

            assert_eq!(

3645

1

                CollatorAssignment::collator_container_chain().container_chains[&1003u32.into()]

3646

1

                    .len(),

3647

1

3648

1

);

3649

3650

            // Send funds to tank

3651

1

            assert_ok!(ServicesPayment::purchase_credits(

3652

1

                origin_of(ALICE.into()),

3653

1

                para_id.into(),

3654

1

                tank_funds,

3655

1

));

3656

3657

            // Set tip for 1003

3658

1

            assert_ok!(ServicesPayment::set_max_tip(

3659

1

                root_origin(),

3660

1

                para_id.into(),

3661

1

                Some(max_tip),

3662

1

));

3663

3664

1

            run_to_session(2);

3665

1

            assert_eq!(

3666

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

3667

1

                    .len(),

3668

1

2,

3669

1

);

3670

1

});

3671

1

3672

3673

#[test]

3674

1

fn test_collator_assignment_tip_charged_on_congestion() {

3675

1

    ExtBuilder::default()

3676

1

        .with_balances(vec![

3677

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3678

1

            (AccountId::from(BOB), 100_000 * UNIT),

3679

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3680

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3681

1

])

3682

1

        .with_collators(vec![

3683

1

            (AccountId::from(ALICE), 210 * UNIT),

3684

1

            (AccountId::from(BOB), 100 * UNIT),

3685

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3686

1

            (AccountId::from(DAVE), 100 * UNIT),

3687

1

])

3688

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3689

1

        .build()

3690

1

        .execute_with(|| {

3691

1

            let tank_funds = 100 * UNIT;

3692

1

            let max_tip = 1 * UNIT;

3693

1

            let para_id = 1003u32;

3694

1

3695

1

            // Send funds to tank

3696

1

            assert_ok!(ServicesPayment::purchase_credits(

3697

1

                origin_of(ALICE.into()),

3698

1

                para_id.into(),

3699

1

                tank_funds,

3700

1

));

3701

3702

            // Set tip for para_id

3703

1

            assert_ok!(ServicesPayment::set_max_tip(

3704

1

                root_origin(),

3705

1

                para_id.into(),

3706

1

                Some(max_tip),

3707

1

));

3708

3709

1

            run_to_session(1);

3710

1

            assert_eq!(

3711

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id.into())),

3712

1

                tank_funds - max_tip,

3713

1

);

3714

1

});

3715

1

3716

3717

#[test]

3718

1

fn test_collator_assignment_tip_not_assigned_on_insufficient_balance() {

3719

1

    ExtBuilder::default()

3720

1

        .with_balances(vec![

3721

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3722

1

            (AccountId::from(BOB), 100_000 * UNIT),

3723

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3724

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3725

1

])

3726

1

        .with_collators(vec![

3727

1

            (AccountId::from(ALICE), 210 * UNIT),

3728

1

            (AccountId::from(BOB), 100 * UNIT),

3729

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3730

1

            (AccountId::from(DAVE), 100 * UNIT),

3731

1

])

3732

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3733

1

        .build()

3734

1

        .execute_with(|| {

3735

1

            let tank_funds = 1 * UNIT;

3736

1

            let max_tip = 1 * UNIT;

3737

1

            let para_id = 1003u32;

3738

1

3739

1

            // Send insufficient funds to tank for tip for 2 sessions

3740

1

            assert_ok!(ServicesPayment::purchase_credits(

3741

1

                origin_of(ALICE.into()),

3742

1

                para_id.into(),

3743

1

                tank_funds,

3744

1

));

3745

3746

            // Set tip for para_id

3747

1

            assert_ok!(ServicesPayment::set_max_tip(

3748

1

                root_origin(),

3749

1

                para_id.into(),

3750

1

                Some(max_tip),

3751

1

));

3752

3753

1

            run_to_session(1);

3754

1

            assert_eq!(

3755

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

3756

1

                    .len(),

3757

1

3758

1

);

3759

1

});

3760

1

3761

3762

#[test]

3763

1

fn test_collator_assignment_tip_only_charge_willing_paras() {

3764

1

    ExtBuilder::default()

3765

1

        .with_balances(vec![

3766

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3767

1

            (AccountId::from(BOB), 100_000 * UNIT),

3768

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3769

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3770

1

            (AccountId::from(EVE), 100_000 * UNIT),

3771

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

3772

1

])

3773

1

        .with_collators(vec![

3774

1

            (AccountId::from(ALICE), 210 * UNIT),

3775

1

            (AccountId::from(BOB), 100 * UNIT),

3776

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3777

1

            (AccountId::from(DAVE), 100 * UNIT),

3778

1

            (AccountId::from(EVE), 100 * UNIT),

3779

1

            (AccountId::from(FERDIE), 100 * UNIT),

3780

1

])

3781

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3782

1

        .build()

3783

1

        .execute_with(|| {

3784

1

            let tank_funds = 100 * UNIT;

3785

1

            let max_tip = 1 * UNIT;

3786

1

            let para_id_with_tip = 1003u32;

3787

1

            let para_id_without_tip = 1001u32;

3788

1

3789

1

            // Send funds to tank to both paras

3790

1

            assert_ok!(ServicesPayment::purchase_credits(

3791

1

                origin_of(ALICE.into()),

3792

1

                para_id_with_tip.into(),

3793

1

                tank_funds,

3794

1

));

3795

1

            assert_ok!(ServicesPayment::purchase_credits(

3796

1

                origin_of(ALICE.into()),

3797

1

                para_id_without_tip.into(),

3798

1

                tank_funds,

3799

1

));

3800

3801

            // Only set tip for 1003

3802

1

            assert_ok!(ServicesPayment::set_max_tip(

3803

1

                root_origin(),

3804

1

                para_id_with_tip.into(),

3805

1

                Some(max_tip),

3806

1

));

3807

3808

1

            run_to_session(2);

3809

1

3810

1

            let assignment = CollatorAssignment::collator_container_chain().container_chains;

3811

1

3812

1

            // 2 out of the 3 paras should have collators assigned, with one paying tip to get

3813

1

            // prioritized, and the other selected at random that should not be charged any tips

3814

1

            assert_eq!(assignment[&para_id_with_tip.into()].len(), 2);

3815

1

            assert_eq!(

3816

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_with_tip.into())),

3817

1

                tank_funds - max_tip * 2,

3818

1

);

3819

3820

1

            assert_eq!(assignment[&para_id_without_tip.into()].len(), 2);

3821

1

            assert_eq!(

3822

1

                Balances::usable_balance(ServicesPayment::parachain_tank(

3823

1

                    para_id_without_tip.into()

3824

1

)),

3825

1

                tank_funds,

3826

1

);

3827

1

});

3828

1

3829

3830

#[test]

3831

1

fn test_collator_assignment_tip_withdraw_min_tip() {

3832

1

    ExtBuilder::default()

3833

1

        .with_balances(vec![

3834

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3835

1

            (AccountId::from(BOB), 100_000 * UNIT),

3836

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3837

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3838

1

            (AccountId::from(EVE), 100_000 * UNIT),

3839

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

3840

1

])

3841

1

        .with_collators(vec![

3842

1

            (AccountId::from(ALICE), 210 * UNIT),

3843

1

            (AccountId::from(BOB), 100 * UNIT),

3844

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3845

1

            (AccountId::from(DAVE), 100 * UNIT),

3846

1

            (AccountId::from(EVE), 100 * UNIT),

3847

1

            (AccountId::from(FERDIE), 100 * UNIT),

3848

1

])

3849

1

        .with_empty_parachains(vec![1001, 1002, 1003])

3850

1

        .build()

3851

1

        .execute_with(|| {

3852

1

            let tank_funds = 100 * UNIT;

3853

1

            let max_tip_1003 = 3 * UNIT;

3854

1

            let max_tip_1002 = 2 * UNIT;

3855

1

            let para_id_1003 = 1003u32;

3856

1

            let para_id_1002 = 1002u32;

3857

1

3858

1

            // Send funds to tank to both paras

3859

1

            assert_ok!(ServicesPayment::purchase_credits(

3860

1

                origin_of(ALICE.into()),

3861

1

                para_id_1003.into(),

3862

1

                tank_funds,

3863

1

));

3864

1

            assert_ok!(ServicesPayment::purchase_credits(

3865

1

                origin_of(ALICE.into()),

3866

1

                para_id_1002.into(),

3867

1

                tank_funds,

3868

1

));

3869

3870

            // Set tips

3871

1

            assert_ok!(ServicesPayment::set_max_tip(

3872

1

                root_origin(),

3873

1

                para_id_1003.into(),

3874

1

                Some(max_tip_1003),

3875

1

));

3876

1

            assert_ok!(ServicesPayment::set_max_tip(

3877

1

                root_origin(),

3878

1

                para_id_1002.into(),

3879

1

                Some(max_tip_1002),

3880

1

));

3881

3882

1

            run_to_session(2);

3883

1

3884

1

            assert_eq!(

3885

1

                CollatorAssignment::collator_container_chain().container_chains

3886

1

                    [&para_id_1003.into()]

3887

1

                    .len(),

3888

1

3889

1

);

3890

1

            assert_eq!(

3891

1

                CollatorAssignment::collator_container_chain().container_chains

3892

1

                    [&para_id_1002.into()]

3893

1

                    .len(),

3894

1

3895

1

);

3896

3897

            // Should have withdrawn the lowest tip from both paras

3898

1

            assert_eq!(

3899

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1003.into())),

3900

1

                tank_funds - max_tip_1002 * 2,

3901

1

);

3902

3903

1

            assert_eq!(

3904

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1002.into())),

3905

1

                tank_funds - max_tip_1002 * 2,

3906

1

);

3907

1

});

3908

1

3909

3910

#[test]

3911

1

fn test_migration_data_preservers_assignments() {

3912

1

    ExtBuilder::default().build().execute_with(|| {

3913

        use {

3914

            crate::{MaxAssignmentsPerParaId, MaxNodeUrlLen},

3915

            frame_support::{

3916

                migration::{have_storage_value, put_storage_value},

3917

                Blake2_128Concat, StorageHasher,

3918

},

3919

            pallet_data_preservers::{ParaIdsFilter, Profile, ProfileMode, RegisteredProfile},

3920

            sp_runtime::BoundedBTreeSet,

3921

            sp_std::collections::btree_set::BTreeSet,

3922

            tanssi_runtime_common::migrations::DataPreserversAssignmentsMigration,

3923

};

3924

3925

        macro_rules! bset {

3926

            ( $($value:expr),* $(,)? ) => {

3927

3928

                    let mut set = BoundedBTreeSet::new();

3929

$(

3930

                        set.try_insert($value).expect("max bound reached");

3931

)*

3932

set

3933

3934

3935

3936

3937

        macro_rules! set {

3938

            ( $($value:expr),* $(,)? ) => {

3939

3940

                    let mut set = BTreeSet::new();

3941

$(

3942

                        set.insert($value);

3943

)*

3944

set

3945

3946

3947

3948

3949

1

        let account = AccountId::from([0u8; 32]);

3950

1

        let free_request = tp_data_preservers_common::ProviderRequest::Free;

3951

1

        let free_witness = tp_data_preservers_common::AssignmentWitness::Free;

3952

1

3953

1

        let pallet_prefix: &[u8] = b"DataPreservers";

3954

1

        let storage_item_prefix: &[u8] = b"BootNodes";

3955

1

3956

1

        // Register 2 parachains

3957

1

        assert_ok!(Registrar::register(

3958

1

            origin_of(ALICE.into()),

3959

1

            1001.into(),

3960

1

            empty_genesis_data(),

3961

1

            None

3962

1

));

3963

1

        assert_ok!(Registrar::register(

3964

1

            origin_of(BOB.into()),

3965

1

            1002.into(),

3966

1

            empty_genesis_data(),

3967

1

            None

3968

1

));

3969

3970

        // Set bootnodes in old storage

3971

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

3972

1

            b"alpha".to_vec().try_into().unwrap(),

3973

1

            b"beta".to_vec().try_into().unwrap(),

3974

1

3975

1

        .try_into()

3976

1

        .unwrap();

3977

1

        put_storage_value(

3978

1

            pallet_prefix,

3979

1

            storage_item_prefix,

3980

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode()),

3981

1

            bootnodes,

3982

1

);

3983

1

3984

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

3985

1

            b"delta".to_vec().try_into().unwrap(),

3986

1

            b"gamma".to_vec().try_into().unwrap(),

3987

1

3988

1

        .try_into()

3989

1

        .unwrap();

3990

1

        put_storage_value(

3991

1

            pallet_prefix,

3992

1

            storage_item_prefix,

3993

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode()),

3994

1

            bootnodes,

3995

1

);

3996

1

3997

1

        // Apply migration

3998

1

        let migration = DataPreserversAssignmentsMigration::<Runtime>(Default::default());

3999

1

        migration.migrate(Default::default());

4000

1

4001

1

        // Check old storage is empty

4002

1

        assert!(!have_storage_value(

4003

1

            pallet_prefix,

4004

1

            storage_item_prefix,

4005

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode())

4006

1

));

4007

1

        assert!(!have_storage_value(

4008

1

            pallet_prefix,

4009

1

            storage_item_prefix,

4010

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode())

4011

1

));

4012

4013

        // Check new storage

4014

1

        assert_eq!(

4015

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1001)).into_inner(),

4016

1

            set![0, 1]

4017

1

);

4018

1

        assert_eq!(

4019

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1002)).into_inner(),

4020

1

            set![2, 3]

4021

1

);

4022

1

        assert_eq!(pallet_data_preservers::NextProfileId::<Runtime>::get(), 4);

4023

1

        assert_eq!(

4024

1

            pallet_data_preservers::Profiles::<Runtime>::get(0),

4025

1

            Some(RegisteredProfile {

4026

1

                account: account.clone(),

4027

1

                deposit: 0,

4028

1

                assignment: Some((1001.into(), free_witness)),

4029

1

                profile: Profile {

4030

1

                    url: b"alpha".to_vec().try_into().unwrap(),

4031

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

4032

1

                    mode: ProfileMode::Bootnode,

4033

1

                    assignment_request: free_request,

4034

1

4035

1

})

4036

1

);

4037

1

        assert_eq!(

4038

1

            pallet_data_preservers::Profiles::<Runtime>::get(1),

4039

1

            Some(RegisteredProfile {

4040

1

                account: account.clone(),

4041

1

                deposit: 0,

4042

1

                assignment: Some((1001.into(), free_witness)),

4043

1

                profile: Profile {

4044

1

                    url: b"beta".to_vec().try_into().unwrap(),

4045

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

4046

1

                    mode: ProfileMode::Bootnode,

4047

1

                    assignment_request: free_request,

4048

1

4049

1

})

4050

1

);

4051

1

        assert_eq!(

4052

1

            pallet_data_preservers::Profiles::<Runtime>::get(2),

4053

1

            Some(RegisteredProfile {

4054

1

                account: account.clone(),

4055

1

                deposit: 0,

4056

1

                assignment: Some((1002.into(), free_witness)),

4057

1

                profile: Profile {

4058

1

                    url: b"delta".to_vec().try_into().unwrap(),

4059

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

4060

1

                    mode: ProfileMode::Bootnode,

4061

1

                    assignment_request: free_request,

4062

1

4063

1

})

4064

1

);

4065

1

        assert_eq!(

4066

1

            pallet_data_preservers::Profiles::<Runtime>::get(3),

4067

1

            Some(RegisteredProfile {

4068

1

                account: account.clone(),

4069

1

                deposit: 0,

4070

1

                assignment: Some((1002.into(), free_witness)),

4071

1

                profile: Profile {

4072

1

                    url: b"gamma".to_vec().try_into().unwrap(),

4073

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

4074

1

                    mode: ProfileMode::Bootnode,

4075

1

                    assignment_request: free_request,

4076

1

4077

1

})

4078

1

);

4079

1

})

4080

1

4081

4082

#[test]

4083

1

fn test_migration_registrar_reserves_to_hold() {

4084

1

    ExtBuilder::default()

4085

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

4086

1

        .build()

4087

1

        .execute_with(|| {

4088

            use {

4089

                frame_support::traits::{fungible::InspectHold, ReservableCurrency},

4090

                pallet_registrar::DepositInfo,

4091

                tanssi_runtime_common::migrations::RegistrarReserveToHoldMigration,

4092

};

4093

4094

1

            let deposit: Balance = 100 * UNIT;

4095

1

            let account: AccountId = DAVE.into();

4096

1

4097

1

            assert_ok!(Balances::reserve(&account, deposit));

4098

4099

1

            pallet_registrar::RegistrarDeposit::<Runtime>::insert(

4100

1

                ParaId::from(1001),

4101

1

                DepositInfo {

4102

1

                    creator: account.clone(),

4103

1

                    deposit,

4104

1

},

4105

1

);

4106

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

4107

            // Apply migration

4108

1

            let migration = RegistrarReserveToHoldMigration::<Runtime>(Default::default());

4109

1

            migration.migrate(Default::default());

4110

1

4111

1

            // Holds also count as reserved balance, so the total reserved amount

4112

1

            // shouldn't change after the migration

4113

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

4114

4115

1

            assert_eq!(

4116

1

                Balances::balance_on_hold(

4117

1

                    &pallet_registrar::HoldReason::RegistrarDeposit.into(),

4118

1

                    &account

4119

1

),

4120

1

                deposit

4121

1

);

4122

1

})

4123

1

4124

4125

#[test]

4126

1

fn test_migration_stream_payment_config_new_fields() {

4127

1

    ExtBuilder::default().build().execute_with(|| {

4128

        use pallet_stream_payment::{

4129

            migrations::{OldChangeRequest, OldStream, OldStreamConfig},

4130

            ChangeKind, ChangeRequest, DepositChange, Party, Stream, StreamConfig,

4131

};

4132

        use tanssi_runtime_common::migrations::MigrateStreamPaymentNewConfigFields;

4133

4134

1

        frame_support::storage::unhashed::put(

4135

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(0),

4136

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

4137

1

                source: ALICE.into(),

4138

1

                target: BOB.into(),

4139

1

                config: OldStreamConfig {

4140

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4141

1

                    asset_id: StreamPaymentAssetId::Native,

4142

1

                    rate: 41,

4143

1

},

4144

1

                deposit: 42,

4145

1

                last_time_updated: 43,

4146

1

                request_nonce: 44,

4147

1

                pending_request: Some(OldChangeRequest {

4148

1

                    requester: Party::Source,

4149

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

4150

1

                    new_config: OldStreamConfig {

4151

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

4152

1

                        asset_id: StreamPaymentAssetId::Native,

4153

1

                        rate: 46,

4154

1

},

4155

1

                    deposit_change: Some(DepositChange::Absolute(47)),

4156

1

}),

4157

1

                opening_deposit: 48,

4158

1

},

4159

1

);

4160

1

4161

1

        frame_support::storage::unhashed::put(

4162

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(1),

4163

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

4164

1

                source: CHARLIE.into(),

4165

1

                target: ALICE.into(),

4166

1

                config: OldStreamConfig {

4167

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4168

1

                    asset_id: StreamPaymentAssetId::Native,

4169

1

                    rate: 100,

4170

1

},

4171

1

                deposit: 101,

4172

1

                last_time_updated: 102,

4173

1

                request_nonce: 103,

4174

1

                pending_request: None,

4175

1

                opening_deposit: 104,

4176

1

},

4177

1

);

4178

1

4179

1

        let migration = MigrateStreamPaymentNewConfigFields::<Runtime>(Default::default());

4180

1

        migration.migrate(Default::default());

4181

1

4182

1

        assert_eq!(

4183

1

            pallet_stream_payment::Streams::<Runtime>::get(0).unwrap(),

4184

1

            Stream {

4185

1

                source: ALICE.into(),

4186

1

                target: BOB.into(),

4187

1

                config: StreamConfig {

4188

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4189

1

                    asset_id: StreamPaymentAssetId::Native,

4190

1

                    rate: 41,

4191

1

                    minimum_request_deadline_delay: 0,

4192

1

                    soft_minimum_deposit: 0,

4193

1

},

4194

1

                deposit: 42,

4195

1

                last_time_updated: 43,

4196

1

                request_nonce: 44,

4197

1

                pending_request: Some(ChangeRequest {

4198

1

                    requester: Party::Source,

4199

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

4200

1

                    new_config: StreamConfig {

4201

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

4202

1

                        asset_id: StreamPaymentAssetId::Native,

4203

1

                        rate: 46,

4204

1

                        minimum_request_deadline_delay: 0,

4205

1

                        soft_minimum_deposit: 0,

4206

1

},

4207

1

                    deposit_change: Some(DepositChange::Absolute(47)),

4208

1

}),

4209

1

                opening_deposit: 48,

4210

1

4211

1

);

4212

4213

1

        assert_eq!(

4214

1

            pallet_stream_payment::Streams::<Runtime>::get(1).unwrap(),

4215

1

            Stream {

4216

1

                source: CHARLIE.into(),

4217

1

                target: ALICE.into(),

4218

1

                config: StreamConfig {

4219

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

4220

1

                    asset_id: StreamPaymentAssetId::Native,

4221

1

                    rate: 100,

4222

1

                    minimum_request_deadline_delay: 0,

4223

1

                    soft_minimum_deposit: 0,

4224

1

},

4225

1

                deposit: 101,

4226

1

                last_time_updated: 102,

4227

1

                request_nonce: 103,

4228

1

                pending_request: None,

4229

1

                opening_deposit: 104,

4230

1

4231

1

);

4232

1

})

4233

1

4234

4235

#[test]

4236

1

fn test_container_deregister_unassign_data_preserver() {

4237

1

    ExtBuilder::default()

4238

1

        .with_balances(vec![

4239

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4240

1

            (AccountId::from(BOB), 100_000 * UNIT),

4241

1

])

4242

1

        .build()

4243

1

        .execute_with(|| {

4244

            use pallet_data_preservers::{

4245

                AssignerParameterOf, ParaIdsFilter, Profile, ProfileMode, ProviderRequestOf,

4246

};

4247

4248

1

            let profile = Profile {

4249

1

                url: b"test".to_vec().try_into().unwrap(),

4250

1

                para_ids: ParaIdsFilter::AnyParaId,

4251

1

                mode: ProfileMode::Bootnode,

4252

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

4253

1

};

4254

1

4255

1

            let para_id = ParaId::from(1002);

4256

1

            let profile_id = 0u64;

4257

1

4258

1

            assert_ok!(Registrar::register(

4259

1

                origin_of(ALICE.into()),

4260

1

                para_id,

4261

1

                empty_genesis_data(),

4262

1

                None

4263

1

));

4264

4265

1

            assert_ok!(DataPreservers::create_profile(

4266

1

                origin_of(BOB.into()),

4267

1

                profile.clone(),

4268

1

));

4269

4270

            // Start assignment

4271

1

            assert_ok!(DataPreservers::start_assignment(

4272

1

                origin_of(ALICE.into()),

4273

1

                profile_id,

4274

1

                para_id,

4275

1

                AssignerParameterOf::<Runtime>::Free

4276

1

));

4277

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&0u64));

4278

4279

            // Deregister from Registrar

4280

1

            assert_ok!(Registrar::deregister(root_origin(), para_id), ());

4281

4282

            // Check DataPreserver assignment has been cleared

4283

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).is_empty());

4284

1

});

4285

1

4286

4287

#[test]

4288

1

fn test_data_preserver_with_stream_payment() {

4289

1

    ExtBuilder::default()

4290

1

        .with_balances(vec![

4291

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4292

1

            (AccountId::from(BOB), 100_000 * UNIT),

4293

1

])

4294

1

        .build()

4295

1

        .execute_with(|| {

4296

            use pallet_data_preservers::{

4297

                AssignerParameterOf, ParaIdsFilter, Profile, ProfileMode, ProviderRequestOf,

4298

};

4299

4300

1

            let profile = Profile {

4301

1

                url: b"test".to_vec().try_into().unwrap(),

4302

1

                para_ids: ParaIdsFilter::AnyParaId,

4303

1

                mode: ProfileMode::Bootnode,

4304

1

                assignment_request: ProviderRequestOf::<Runtime>::StreamPayment {

4305

1

                    config: StreamConfig {

4306

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

4307

1

                        asset_id: StreamPaymentAssetId::Native,

4308

1

                        rate: 42,

4309

1

                        minimum_request_deadline_delay: 0,

4310

1

                        soft_minimum_deposit: 0,

4311

1

},

4312

1

},

4313

1

};

4314

1

4315

1

            let para_id = ParaId::from(1002);

4316

1

            let profile_id = 0u64;

4317

1

4318

1

            assert_ok!(Registrar::register(

4319

1

                origin_of(ALICE.into()),

4320

1

                para_id,

4321

1

                empty_genesis_data(),

4322

1

                None

4323

1

));

4324

4325

1

            assert_ok!(DataPreservers::create_profile(

4326

1

                origin_of(BOB.into()),

4327

1

                profile.clone(),

4328

1

));

4329

4330

            // Start assignment

4331

1

            assert_ok!(DataPreservers::start_assignment(

4332

1

                origin_of(ALICE.into()),

4333

1

                profile_id,

4334

1

                para_id,

4335

1

                AssignerParameterOf::<Runtime>::StreamPayment {

4336

1

                    initial_deposit: 1_000

4337

1

4338

1

));

4339

1

            assert!(

4340

1

                pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&profile_id)

4341

1

);

4342

1

            let profile = pallet_data_preservers::Profiles::<Runtime>::get(&profile_id)

4343

1

                .expect("profile to exists");

4344

1

            let (assigned_para_id, witness) = profile.assignment.expect("profile to be assigned");

4345

1

            assert_eq!(assigned_para_id, para_id);

4346

1

            assert_eq!(

4347

1

                witness,

4348

1

                tp_data_preservers_common::AssignmentWitness::StreamPayment { stream_id: 0 }

4349

1

);

4350

1

});

4351

1

4352

4353

#[test]

4354

1

fn test_data_preserver_kind_needs_to_match() {

4355

1

    ExtBuilder::default()

4356

1

        .with_balances(vec![

4357

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4358

1

            (AccountId::from(BOB), 100_000 * UNIT),

4359

1

])

4360

1

        .build()

4361

1

        .execute_with(|| {

4362

            use pallet_data_preservers::{

4363

                AssignerParameterOf, ParaIdsFilter, Profile, ProfileMode, ProviderRequestOf,

4364

};

4365

4366

1

            let profile = Profile {

4367

1

                url: b"test".to_vec().try_into().unwrap(),

4368

1

                para_ids: ParaIdsFilter::AnyParaId,

4369

1

                mode: ProfileMode::Bootnode,

4370

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

4371

1

};

4372

1

4373

1

            let para_id = ParaId::from(1002);

4374

1

            let profile_id = 0u64;

4375

1

4376

1

            assert_ok!(Registrar::register(

4377

1

                origin_of(ALICE.into()),

4378

1

                para_id,

4379

1

                empty_genesis_data(),

4380

1

                None

4381

1

));

4382

4383

1

            assert_ok!(DataPreservers::create_profile(

4384

1

                origin_of(BOB.into()),

4385

1

                profile.clone(),

4386

1

));

4387

4388

            // Start assignment

4389

1

            assert_err!(

4390

1

                DataPreservers::start_assignment(

4391

1

                    origin_of(ALICE.into()),

4392

1

                    profile_id,

4393

1

                    para_id,

4394

1

                    AssignerParameterOf::<Runtime>::StreamPayment {

4395

1

                        initial_deposit: 1_000

4396

1

4397

1

),

4398

1

                pallet_data_preservers::Error::<Runtime>::AssignmentPaymentRequestParameterMismatch

4399

1

);

4400

1

});

4401

1

4402

4403

#[test]

4404

1

fn test_registrar_extrinsic_permissions() {

4405

1

    ExtBuilder::default()

4406

1

        .with_balances(vec![

4407

1

4408

1

                cumulus_primitives_core::relay_chain::AccountId::from(ALICE),

4409

1

                210_000 * UNIT,

4410

1

),

4411

1

4412

1

                cumulus_primitives_core::relay_chain::AccountId::from(BOB),

4413

1

                100_000 * UNIT,

4414

1

),

4415

1

])

4416

1

        .with_empty_parachains(vec![1001])

4417

1

        .build()

4418

1

        .execute_with(|| {

4419

1

            let para_id = ParaId::from(1001);

4420

1

4421

1

            // Pause container chain should fail if not para manager

4422

1

            assert_noop!(

4423

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

4424

1

                BadOrigin

4425

1

);

4426

4427

            // Set Bob as para manager

4428

1

            assert_ok!(Registrar::set_para_manager(

4429

1

                root_origin(),

4430

1

                para_id,

4431

1

                AccountId::from(BOB)

4432

1

));

4433

4434

            // Pause container chain should succeed if para manager

4435

1

            assert_ok!(

4436

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

4437

1

()

4438

1

);

4439

1

});

4440

1