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

    cumulus_primitives_core::ParaId,

21

    dancebox_runtime::{RewardsCollatorCommission, StreamPayment, TransactionPayment},

22

    dancebox_runtime_test_utils::*,

23

    dp_consensus::runtime_decl_for_tanssi_authority_assignment_api::TanssiAuthorityAssignmentApiV1,

24

    dp_core::well_known_keys,

25

    frame_support::{

26

        assert_err, assert_noop, assert_ok, migrations::SteppedMigration,

27

        pallet_prelude::StorageVersion, weights::WeightMeter, BoundedVec,

28

},

29

    frame_system::ConsumedWeight,

30

    nimbus_primitives::NIMBUS_KEY_ID,

31

    pallet_author_noting_runtime_api::runtime_decl_for_author_noting_api::AuthorNotingApi,

32

    pallet_balances::Instance1,

33

    pallet_migrations::Migration,

34

    pallet_pooled_staking::{

35

        traits::IsCandidateEligible, ActivePoolKind, EligibleCandidate, PendingOperationKey,

36

        PendingOperationQuery, PoolKind, PoolsKey, SharesOrStake,

37

},

38

    pallet_registrar_runtime_api::{

39

        runtime_decl_for_registrar_api::RegistrarApi, ContainerChainGenesisData,

40

},

41

    pallet_stream_payment::StreamConfig,

42

    parity_scale_codec::Encode,

43

    rococo_runtime_constants::fee::Perbill,

44

    sp_consensus_aura::AURA_ENGINE_ID,

45

    sp_core::Get,

46

    sp_runtime::{

47

        traits::{BadOrigin, BlakeTwo256, OpaqueKeys},

48

        DigestItem, FixedU128,

49

},

50

    tanssi_runtime_common::migrations::{

51

        HostConfigurationV3, MigrateConfigurationAddFullRotationMode,

52

        MigrateServicesPaymentAddCollatorAssignmentCredits, RegistrarPendingVerificationValueToMap,

53

},

54

    test_relay_sproof_builder::{HeaderAs, ParaHeaderSproofBuilder, ParaHeaderSproofBuilderItem},

55

    tp_stream_payment_common::{

56

        AssetId as StreamPaymentAssetId, TimeUnit as StreamPaymentTimeUnit,

57

},

58

    tp_traits::{ContainerChainBlockInfo, SlotFrequency},

59

    xcm::latest::prelude::*,

60

};

61

62

#[test]

63

1

fn genesis_balances() {

64

1

    ExtBuilder::default()

65

1

        .with_balances(vec![

66

1

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

67

1

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

68

1

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

69

1

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

70

1

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

71

1

])

72

1

        .with_collators(vec![

73

1

            // Remove ALICE and BOB from collators

74

1

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

75

1

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

76

1

])

77

1

        .build()

78

1

        .execute_with(|| {

79

1

            assert_eq!(

80

1

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

81

                210_000 * UNIT,

82

);

83

1

            assert_eq!(

84

1

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

85

                100_000 * UNIT,

86

);

87

1

});

88

1

89

90

#[test]

91

1

fn genesis_para_registrar() {

92

1

    ExtBuilder::default()

93

1

        .with_empty_parachains(vec![1001, 1002])

94

1

        .build()

95

1

        .execute_with(|| {

96

1

            assert_eq!(

97

1

                Registrar::registered_para_ids(),

98

1

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

99

);

100

1

});

101

1

102

103

#[test]

104

1

fn genesis_para_registrar_deregister() {

105

1

    ExtBuilder::default()

106

1

        .with_empty_parachains(vec![1001, 1002])

107

1

        .build()

108

1

        .execute_with(|| {

109

1

            assert_eq!(

110

1

                Registrar::registered_para_ids(),

111

1

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

112

);

113

114

1

            run_to_block(2);

115

1

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

116

117

            // Pending

118

1

            assert_eq!(

119

1

                Registrar::pending_registered_para_ids(),

120

1

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

121

);

122

123

1

            run_to_session(1);

124

1

            assert_eq!(

125

1

                Registrar::pending_registered_para_ids(),

126

1

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

127

);

128

1

            assert_eq!(

129

1

                Registrar::registered_para_ids(),

130

1

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

131

);

132

133

1

            run_to_session(2);

134

1

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

135

1

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

136

1

});

137

1

138

139

#[test]

140

1

fn genesis_para_registrar_runtime_api() {

141

1

    ExtBuilder::default()

142

1

        .with_empty_parachains(vec![1001, 1002])

143

1

        .build()

144

1

        .execute_with(|| {

145

1

            assert_eq!(

146

1

                Registrar::registered_para_ids(),

147

1

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

148

);

149

1

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

150

151

1

            run_to_block(2);

152

1

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

153

1

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

154

155

1

            run_to_session(1);

156

1

            assert_eq!(

157

1

                Registrar::registered_para_ids(),

158

1

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

159

);

160

1

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

161

162

1

            run_to_session(2);

163

1

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

164

1

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

165

1

});

166

1

167

168

#[test]

169

1

fn genesis_para_registrar_container_chain_genesis_data_runtime_api() {

170

1

    let genesis_data_1001 = empty_genesis_data();

171

1

    let genesis_data_1002 = ContainerChainGenesisData {

172

1

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

173

1

        name: Default::default(),

174

1

        id: Default::default(),

175

1

        fork_id: Default::default(),

176

1

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

177

1

        properties: Default::default(),

178

1

};

179

1

    ExtBuilder::default()

180

1

        .with_para_ids(vec![

181

1

            ParaRegistrationParams {

182

1

                para_id: 1001,

183

1

                genesis_data: genesis_data_1001.clone(),

184

1

                block_production_credits: u32::MAX,

185

1

                collator_assignment_credits: u32::MAX,

186

1

                parathread_params: None,

187

1

            },ParaRegistrationParams {

188

1

                para_id: 1002,

189

1

                genesis_data: genesis_data_1002.clone(),

190

1

                block_production_credits: u32::MAX,

191

1

                collator_assignment_credits: u32::MAX,

192

1

                parathread_params: None,

193

1

},

194

1

])

195

1

        .build()

196

1

        .execute_with(|| {

197

1

            assert_eq!(

198

1

                Registrar::registered_para_ids(),

199

1

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

200

);

201

1

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

202

203

1

            assert_eq!(

204

1

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

205

1

                Some(&genesis_data_1001)

206

);

207

1

            assert_eq!(

208

1

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

209

1

                Some(&genesis_data_1002)

210

);

211

1

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

212

213

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

214

            // with id 100

215

            // TODO: where is that 100 defined?

216

1

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

217

218

1

            run_to_block(2);

219

1

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

220

221

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

222

223

1

            let genesis_data_1003 = ContainerChainGenesisData {

224

1

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

225

1

                name: Default::default(),

226

1

                id: Default::default(),

227

1

                fork_id: Default::default(),

228

1

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

229

1

                properties: Default::default(),

230

1

};

231

1

            assert_ok!(

232

1

                Registrar::register(

233

1

                    origin_of(ALICE.into()),

234

1

                    1003.into(),

235

1

                    genesis_data_1003.clone(),

236

1

                    None

237

),

238

()

239

);

240

241

            // Registered container chains are inserted immediately

242

1

            assert_eq!(

243

1

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

244

1

                Some(&genesis_data_1003)

245

);

246

247

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

248

1

            run_to_session(2u32);

249

1

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

250

1

});

251

1

252

253

#[test]

254

1

fn test_author_collation_aura() {

255

1

    ExtBuilder::default()

256

1

        .with_empty_parachains(vec![1001, 1002])

257

1

        .build()

258

1

        .execute_with(|| {

259

1

            run_to_block(5);

260

            // Assert current slot gets updated

261

1

            assert_eq!(current_slot(), 4u64);

262

            // slot 4, alice

263

1

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

264

265

1

            run_to_block(6);

266

267

1

            assert_eq!(current_slot(), 5u64);

268

            // slot 5, bob

269

1

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

270

1

});

271

1

272

273

#[test]

274

1

fn test_author_collation_aura_change_of_authorities_on_session() {

275

1

    ExtBuilder::default()

276

1

        .with_balances(vec![

277

1

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

278

1

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

279

1

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

280

1

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

281

1

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

282

1

])

283

1

        .with_empty_parachains(vec![1001, 1002])

284

1

        .build()

285

1

        .execute_with(|| {

286

1

            run_to_block(2);

287

            // Assert current slot gets updated

288

1

            assert_eq!(current_slot(), 1u64);

289

1

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

290

291

            // We change invulnerables

292

            // We first need to set the keys

293

1

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

294

1

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

295

296

1

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

297

1

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

298

299

            // Set CHARLIE and DAVE keys

300

1

            assert_ok!(Session::set_keys(

301

1

                origin_of(CHARLIE.into()),

302

1

                dancebox_runtime::SessionKeys {

303

1

                    nimbus: charlie_id.clone(),

304

1

},

305

1

                vec![]

306

));

307

1

            assert_ok!(Session::set_keys(

308

1

                origin_of(DAVE.into()),

309

1

                dancebox_runtime::SessionKeys {

310

1

                    nimbus: dave_id.clone(),

311

1

},

312

1

                vec![]

313

));

314

315

            // Change invulnerables

316

1

            assert_ok!(Invulnerables::remove_invulnerable(

317

1

                root_origin(),

318

1

                ALICE.into()

319

));

320

1

            assert_ok!(Invulnerables::remove_invulnerable(

321

1

                root_origin(),

322

1

                BOB.into()

323

));

324

1

            assert_ok!(Invulnerables::add_invulnerable(

325

1

                root_origin(),

326

1

                CHARLIE.into()

327

));

328

1

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

329

330

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

331

1

            run_to_session(1u32);

332

1

            let author = get_orchestrator_current_author().unwrap();

333

334

1

            assert_eq!(current_author(), author);

335

1

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

336

337

            // Invulnerables should have triggered on new session authorities change

338

1

            run_to_session(2u32);

339

1

            let author_after_changes = get_orchestrator_current_author().unwrap();

340

341

1

            assert_eq!(current_author(), author_after_changes);

342

1

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

343

1

});

344

1

345

346

#[test]

347

1

fn test_author_collation_aura_add_assigned_to_paras() {

348

1

    ExtBuilder::default()

349

1

        .with_balances(vec![

350

1

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

351

1

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

352

1

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

353

1

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

354

1

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

355

1

])

356

1

        .with_empty_parachains(vec![1001, 1002])

357

1

        .build()

358

1

        .execute_with(|| {

359

1

            run_to_block(2);

360

            // Assert current slot gets updated

361

1

            assert_eq!(current_slot(), 1u64);

362

1

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

363

364

            // We change invulnerables

365

            // We first need to set the keys

366

1

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

367

1

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

368

369

1

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

370

1

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

371

372

            // Set CHARLIE and DAVE keys

373

1

            assert_ok!(Session::set_keys(

374

1

                origin_of(CHARLIE.into()),

375

1

                dancebox_runtime::SessionKeys { nimbus: charlie_id },

376

1

                vec![]

377

));

378

1

            assert_ok!(Session::set_keys(

379

1

                origin_of(DAVE.into()),

380

1

                dancebox_runtime::SessionKeys { nimbus: dave_id },

381

1

                vec![]

382

));

383

384

            // Add new invulnerables

385

1

            assert_ok!(Invulnerables::add_invulnerable(

386

1

                root_origin(),

387

1

                CHARLIE.into()

388

));

389

1

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

390

391

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

392

1

            run_to_session(1u32);

393

1

            let author = get_orchestrator_current_author().unwrap();

394

395

1

            assert_eq!(current_author(), author);

396

1

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

397

398

            // Invulnerables should have triggered on new session authorities change

399

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

400

1

            run_to_session(2u32);

401

1

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

402

1

            let assignment = CollatorAssignment::collator_container_chain();

403

1

            assert_eq!(

404

1

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

405

1

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

406

);

407

1

});

408

1

409

410

#[test]

411

1

fn test_authors_without_paras() {

412

1

    ExtBuilder::default()

413

1

        .with_balances(vec![

414

1

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

415

1

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

416

1

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

417

1

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

418

1

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

419

1

])

420

1

        .with_collators(vec![

421

1

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

422

1

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

423

1

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

424

1

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

425

1

])

426

1

        .build()

427

1

        .execute_with(|| {

428

1

            run_to_block(2);

429

            // Assert current slot gets updated

430

1

            assert_eq!(current_slot(), 1u64);

431

1

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

432

433

            // Only Alice and Bob collate for our chain

434

1

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

435

1

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

436

1

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

437

1

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

438

439

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

440

1

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

441

442

            // Set moondance collators to min 2 max 5

443

1

            assert_ok!(

444

1

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

445

()

446

);

447

1

            assert_ok!(

448

1

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

449

()

450

);

451

452

1

            run_to_session(2);

453

1

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

454

1

});

455

1

456

457

#[test]

458

1

fn test_authors_paras_inserted_a_posteriori() {

459

1

    ExtBuilder::default()

460

1

        .with_balances(vec![

461

1

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

462

1

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

463

1

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

464

1

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

465

1

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

466

1

])

467

1

        .with_collators(vec![

468

1

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

469

1

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

470

1

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

471

1

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

472

1

])

473

1

        .build()

474

1

        .execute_with(|| {

475

1

            run_to_block(2);

476

            // Assert current slot gets updated

477

1

            assert_eq!(current_slot(), 1u64);

478

1

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

479

480

            // Alice and Bob collate in our chain

481

1

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

482

1

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

483

484

1

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

485

486

1

            assert_ok!(Registrar::register(

487

1

                origin_of(ALICE.into()),

488

1

                1001.into(),

489

1

                empty_genesis_data(),

490

1

                None

491

));

492

1

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

493

1

            assert_ok!(Registrar::mark_valid_for_collating(

494

1

                root_origin(),

495

1

                1001.into()

496

));

497

1

            assert_ok!(ServicesPayment::purchase_credits(

498

1

                origin_of(ALICE.into()),

499

1

                1001.into(),

500

1

                block_credits_to_required_balance(1000, 1001.into())

501

));

502

1

            assert_ok!(Registrar::register(

503

1

                origin_of(ALICE.into()),

504

1

                1002.into(),

505

1

                empty_genesis_data(),

506

1

                None

507

));

508

1

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

509

1

            assert_ok!(Registrar::mark_valid_for_collating(

510

1

                root_origin(),

511

1

                1002.into()

512

));

513

1

            assert_ok!(ServicesPayment::purchase_credits(

514

1

                origin_of(ALICE.into()),

515

1

                1002.into(),

516

1

                block_credits_to_required_balance(1000, 1002.into())

517

));

518

519

            // Assignment should happen after 2 sessions

520

1

            run_to_session(1u32);

521

1

            let assignment = CollatorAssignment::collator_container_chain();

522

1

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

523

1

            run_to_session(2u32);

524

525

            // Charlie and Dave should be assigned to para 1001

526

1

            let assignment = CollatorAssignment::collator_container_chain();

527

1

            assert_eq!(

528

1

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

529

1

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

530

);

531

1

});

532

1

533

534

#[test]

535

1

fn test_authors_paras_inserted_a_posteriori_with_collators_already_assigned() {

536

1

    ExtBuilder::default()

537

1

        .with_balances(vec![

538

1

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

539

1

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

540

1

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

541

1

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

542

1

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

543

1

])

544

1

        .with_collators(vec![

545

1

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

546

1

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

547

1

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

548

1

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

549

1

])

550

1

        .with_config(pallet_configuration::HostConfiguration {

551

1

            max_collators: 100,

552

1

            min_orchestrator_collators: 2,

553

1

            max_orchestrator_collators: 5,

554

1

            collators_per_container: 2,

555

1

            full_rotation_period: 24,

556

1

            ..Default::default()

557

1

})

558

1

        .build()

559

1

        .execute_with(|| {

560

1

            run_to_block(2);

561

            // Assert current slot gets updated

562

1

            assert_eq!(current_slot(), 1u64);

563

1

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

564

565

            // Alice and Bob collate in our chain

566

1

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

567

1

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

568

1

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

569

1

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

570

571

1

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

572

573

1

            assert_ok!(Registrar::register(

574

1

                origin_of(ALICE.into()),

575

1

                1001.into(),

576

1

                empty_genesis_data(),

577

1

                None

578

));

579

1

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

580

1

            assert_ok!(Registrar::mark_valid_for_collating(

581

1

                root_origin(),

582

1

                1001.into()

583

));

584

1

            assert_ok!(ServicesPayment::purchase_credits(

585

1

                origin_of(ALICE.into()),

586

1

                1001.into(),

587

1

                block_credits_to_required_balance(1000, 1001.into())

588

));

589

590

            // Assignment should happen after 2 sessions

591

1

            run_to_session(1u32);

592

1

            let assignment = CollatorAssignment::collator_container_chain();

593

1

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

594

1

            run_to_session(2u32);

595

596

            // Charlie and Dave are now assigned to para 1001

597

1

            let assignment = CollatorAssignment::collator_container_chain();

598

1

            assert_eq!(

599

1

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

600

1

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

601

);

602

1

            assert_eq!(

603

                assignment.orchestrator_chain,

604

1

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

605

);

606

1

});

607

1

608

609

#[test]

610

1

fn test_paras_registered_but_zero_credits() {

611

1

    ExtBuilder::default()

612

1

        .with_balances(vec![

613

1

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

614

1

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

615

1

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

616

1

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

617

1

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

618

1

])

619

1

        .with_collators(vec![

620

1

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

621

1

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

622

1

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

623

1

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

624

1

])

625

1

        .build()

626

1

        .execute_with(|| {

627

1

            run_to_block(2);

628

            // Assert current slot gets updated

629

1

            assert_eq!(current_slot(), 1u64);

630

1

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

631

632

            // Alice and Bob collate in our chain

633

1

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

634

1

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

635

636

1

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

637

638

1

            assert_ok!(Registrar::register(

639

1

                origin_of(ALICE.into()),

640

1

                1001.into(),

641

1

                empty_genesis_data(),

642

1

                None

643

));

644

1

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

645

1

            assert_ok!(Registrar::mark_valid_for_collating(

646

1

                root_origin(),

647

1

                1001.into()

648

));

649

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

650

1

            assert_ok!(ServicesPayment::set_block_production_credits(

651

1

                root_origin(),

652

1

                1001.into(),

653

654

));

655

656

            // Assignment should happen after 2 sessions

657

1

            run_to_session(1u32);

658

1

            let assignment = CollatorAssignment::collator_container_chain();

659

1

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

660

1

            run_to_session(2u32);

661

662

            // Nobody should be assigned to para 1001

663

1

            let assignment = CollatorAssignment::collator_container_chain();

664

1

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

665

1

});

666

1

667

668

#[test]

669

1

fn test_paras_registered_but_not_enough_credits() {

670

1

    ExtBuilder::default()

671

1

        .with_balances(vec![

672

1

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

673

1

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

674

1

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

675

1

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

676

1

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

677

1

])

678

1

        .with_collators(vec![

679

1

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

680

1

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

681

1

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

682

1

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

683

1

])

684

1

        .build()

685

1

        .execute_with(|| {

686

1

            run_to_block(2);

687

            // Assert current slot gets updated

688

1

            assert_eq!(current_slot(), 1u64);

689

1

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

690

691

            // Alice and Bob collate in our chain

692

1

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

693

1

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

694

695

1

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

696

697

1

            assert_ok!(Registrar::register(

698

1

                origin_of(ALICE.into()),

699

1

                1001.into(),

700

1

                empty_genesis_data(),

701

1

                None

702

));

703

1

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

704

1

            assert_ok!(Registrar::mark_valid_for_collating(

705

1

                root_origin(),

706

1

                1001.into()

707

));

708

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

709

1

            assert_ok!(ServicesPayment::set_block_production_credits(

710

1

                root_origin(),

711

1

                1001.into(),

712

713

));

714

            // Purchase 1 credit less that what is needed

715

1

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

716

1

            assert_ok!(ServicesPayment::set_block_production_credits(

717

1

                root_origin(),

718

1

                1001.into(),

719

1

                credits_1001

720

));

721

722

            // Assignment should happen after 2 sessions

723

1

            run_to_session(1u32);

724

1

            let assignment = CollatorAssignment::collator_container_chain();

725

1

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

726

1

            run_to_session(2u32);

727

            // Nobody should be assigned to para 1001

728

1

            let assignment = CollatorAssignment::collator_container_chain();

729

1

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

730

731

            // Now purchase the missing block credit

732

1

            assert_ok!(ServicesPayment::set_block_production_credits(

733

1

                root_origin(),

734

1

                1001.into(),

735

1

                credits_1001 + 1

736

));

737

738

1

            run_to_session(4u32);

739

            // Charlie and Dave should be assigned to para 1001

740

1

            let assignment = CollatorAssignment::collator_container_chain();

741

1

            assert_eq!(

742

1

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

743

1

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

744

);

745

1

});

746

1

747

748

#[test]

749

1

fn test_paras_registered_but_only_credits_for_1_session() {

750

1

    ExtBuilder::default()

751

1

        .with_balances(vec![

752

1

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

753

1

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

754

1

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

755

1

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

756

1

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

757

1

])

758

1

        .with_collators(vec![

759

1

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

760

1

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

761

1

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

762

1

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

763

1

])

764

1

        .build()

765

1

        .execute_with(|| {

766

1

            run_to_block(2);

767

            // Assert current slot gets updated

768

1

            assert_eq!(current_slot(), 1u64);

769

1

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

770

771

            // Alice and Bob collate in our chain

772

1

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

773

1

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

774

775

1

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

776

777

1

            assert_ok!(Registrar::register(

778

1

                origin_of(ALICE.into()),

779

1

                1001.into(),

780

1

                empty_genesis_data(),

781

1

                None

782

));

783

1

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

784

1

            assert_ok!(Registrar::mark_valid_for_collating(

785

1

                root_origin(),

786

1

                1001.into()

787

));

788

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

789

1

            assert_ok!(ServicesPayment::set_block_production_credits(

790

1

                root_origin(),

791

1

                1001.into(),

792

793

));

794

            // Purchase only enough credits for 1 session

795

1

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

796

1

            assert_ok!(ServicesPayment::set_block_production_credits(

797

1

                root_origin(),

798

1

                1001.into(),

799

1

                credits_1001

800

));

801

802

            // Assignment should happen after 2 sessions

803

1

            run_to_session(1u32);

804

1

            let assignment = CollatorAssignment::collator_container_chain();

805

1

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

806

1

            run_to_session(2u32);

807

            // Charlie and Dave should be assigned to para 1001

808

1

            let assignment = CollatorAssignment::collator_container_chain();

809

1

            assert_eq!(

810

1

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

811

1

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

812

);

813

814

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

815

1

            run_block();

816

1

            let credits =

817

1

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

818

1

                    .unwrap_or_default();

819

1

            assert_eq!(credits, credits_1001);

820

821

            // Simulate block inclusion from container chain 1001

822

1

            let mut sproof = ParaHeaderSproofBuilder::default();

823

1

            let slot: u64 = 5;

824

1

            let s = ParaHeaderSproofBuilderItem {

825

1

                para_id: 1001.into(),

826

1

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

827

1

                    parent_hash: Default::default(),

828

1

                    number: 1,

829

1

                    state_root: Default::default(),

830

1

                    extrinsics_root: Default::default(),

831

1

                    digest: sp_runtime::generic::Digest {

832

1

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

833

1

},

834

1

}),

835

1

};

836

1

            sproof.items.push(s);

837

1

            set_author_noting_inherent_data(sproof);

838

839

1

            run_block();

840

1

            let credits =

841

1

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

842

1

                    .unwrap_or_default();

843

1

            assert_eq!(credits, credits_1001 - 1);

844

845

1

            run_to_session(4u32);

846

            // Nobody should be assigned to para 1001

847

1

            let assignment = CollatorAssignment::collator_container_chain();

848

1

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

849

850

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

851

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

852

1

            let credits =

853

1

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

854

1

                    .unwrap_or_default();

855

1

            assert_eq!(credits, credits_1001 - 1);

856

1

});

857

1

858

859

#[test]

860

1

fn test_parachains_deregister_collators_re_assigned() {

861

1

    ExtBuilder::default()

862

1

        .with_balances(vec![

863

1

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

864

1

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

865

1

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

866

1

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

867

1

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

868

1

])

869

1

        .with_collators(vec![

870

1

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

871

1

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

872

1

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

873

1

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

874

1

])

875

1

        .with_empty_parachains(vec![1001, 1002])

876

1

        .build()

877

1

        .execute_with(|| {

878

1

            run_to_block(2);

879

            // Assert current slot gets updated

880

1

            assert_eq!(current_slot(), 1u64);

881

1

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

882

883

            // Alice and Bob are authorities

884

1

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

885

1

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

886

887

1

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

888

889

            // Charlie and Dave to 1001

890

1

            let assignment = CollatorAssignment::collator_container_chain();

891

1

            assert_eq!(

892

1

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

893

1

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

894

);

895

896

1

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

897

898

            // Assignment should happen after 2 sessions

899

1

            run_to_session(1u32);

900

901

1

            let assignment = CollatorAssignment::collator_container_chain();

902

1

            assert_eq!(

903

1

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

904

1

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

905

);

906

907

1

            run_to_session(2u32);

908

909

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

910

1

            let assignment = CollatorAssignment::collator_container_chain();

911

1

            assert_eq!(

912

1

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

913

1

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

914

);

915

1

});

916

1

917

918

#[test]

919

1

fn test_parachains_deregister_collators_config_change_reassigned() {

920

1

    ExtBuilder::default()

921

1

        .with_balances(vec![

922

1

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

923

1

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

924

1

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

925

1

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

926

1

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

927

1

])

928

1

        .with_collators(vec![

929

1

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

930

1

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

931

1

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

932

1

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

933

1

])

934

1

        .with_empty_parachains(vec![1001, 1002])

935

1

        .build()

936

1

        .execute_with(|| {

937

1

            run_to_block(2);

938

            // Assert current slot gets updated

939

1

            assert_eq!(current_slot(), 1u64);

940

1

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

941

942

            // Alice and Bob are authorities

943

1

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

944

1

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

945

946

1

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

947

948

            // Set orchestrator collators to 1

949

1

            assert_ok!(

950

1

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

951

()

952

);

953

954

            // Set container chain collators to 3

955

1

            assert_ok!(

956

1

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

957

()

958

);

959

960

            // Charlie and Dave to 1001

961

1

            let assignment = CollatorAssignment::collator_container_chain();

962

1

            assert_eq!(

963

1

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

964

1

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

965

);

966

967

            // Assignment should happen after 2 sessions

968

1

            run_to_session(1u32);

969

970

1

            let assignment = CollatorAssignment::collator_container_chain();

971

1

            assert_eq!(

972

1

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

973

1

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

974

);

975

976

1

            run_to_session(2u32);

977

978

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

979

1

            let assignment = CollatorAssignment::collator_container_chain();

980

1

            assert_eq!(

981

1

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

982

1

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

983

);

984

985

1

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

986

1

});

987

1

988

989

#[test]

990

1

fn test_orchestrator_collators_with_non_sufficient_collators() {

991

1

    ExtBuilder::default()

992

1

        .with_balances(vec![

993

1

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

994

1

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

995

1

])

996

1

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

997

1

        .with_empty_parachains(vec![1001, 1002])

998

1

        .build()

999

1

        .execute_with(|| {

1000

1

            run_to_block(2);

1001

            // Assert current slot gets updated

1002

1

            assert_eq!(current_slot(), 1u64);

1003

1

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

1004

1005

            // Alice and Bob are authorities

1006

1

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

1007

1008

1

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

1009

1

});

1010

1

1011

1012

#[test]

1013

1

fn test_configuration_on_session_change() {

1014

1

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

1015

1

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

1016

1

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

1017

1

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

1018

1019

1

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

1020

1

        run_to_session(1u32);

1021

1022

1

        assert_ok!(

1023

1

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

1024

()

1025

);

1026

1

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

1027

1

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

1028

1

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

1029

1030

1

        run_to_session(2u32);

1031

1

        assert_ok!(

1032

1

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

1033

()

1034

);

1035

1

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

1036

1

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

1037

1

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

1038

1039

1

        run_to_session(3u32);

1040

1041

1

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

1042

1

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

1043

1

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

1044

1045

1

        run_to_session(4u32);

1046

1047

1

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

1048

1

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

1049

1

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

1050

1

});

1051

1

1052

1053

#[test]

1054

1

fn test_author_collation_aura_add_assigned_to_paras_runtime_api() {

1055

1

    ExtBuilder::default()

1056

1

        .with_balances(vec![

1057

1

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

1058

1

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

1059

1

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

1060

1

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

1061

1

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

1062

1

])

1063

1

        .with_empty_parachains(vec![1001, 1002])

1064

1

        .build()

1065

1

        .execute_with(|| {

1066

1

            run_to_block(2);

1067

            // Assert current slot gets updated

1068

1

            assert_eq!(current_slot(), 1u64);

1069

1

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

1070

1

            assert_eq!(

1071

1

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

1072

1

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

1073

);

1074

1

            assert_eq!(

1075

1

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

1076

1

                Some(vec![])

1077

);

1078

1

            assert_eq!(

1079

1

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

1080

1

                Some(100.into())

1081

);

1082

1

            assert_eq!(

1083

1

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

1084

1

                Some(100.into())

1085

);

1086

1

            assert_eq!(

1087

1

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

1088

                None

1089

);

1090

1

            assert_eq!(

1091

1

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

1092

                None

1093

);

1094

1095

            // We change invulnerables

1096

            // We first need to set the keys

1097

1

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

1098

1

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

1099

1100

1

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

1101

1

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

1102

1103

            // Set CHARLIE and DAVE keys

1104

1

            assert_ok!(Session::set_keys(

1105

1

                origin_of(CHARLIE.into()),

1106

1

                dancebox_runtime::SessionKeys { nimbus: charlie_id },

1107

1

                vec![]

1108

));

1109

1

            assert_ok!(Session::set_keys(

1110

1

                origin_of(DAVE.into()),

1111

1

                dancebox_runtime::SessionKeys { nimbus: dave_id },

1112

1

                vec![]

1113

));

1114

1115

            // Set new invulnerables

1116

1

            assert_ok!(Invulnerables::add_invulnerable(

1117

1

                root_origin(),

1118

1

                CHARLIE.into()

1119

));

1120

1

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

1121

1122

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

1123

1

            run_to_session(1u32);

1124

1

            let author = get_orchestrator_current_author().unwrap();

1125

1126

1

            assert_eq!(current_author(), author);

1127

1

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

1128

1

            assert_eq!(

1129

1

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

1130

1

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

1131

);

1132

1

            assert_eq!(

1133

1

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

1134

1

                Some(vec![])

1135

);

1136

1

            assert_eq!(

1137

1

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

1138

                None

1139

);

1140

1

            assert_eq!(

1141

1

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

1142

1

                Some(1001.into())

1143

);

1144

1145

            // Invulnerables should have triggered on new session authorities change

1146

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

1147

1

            run_to_session(2u32);

1148

1

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

1149

1

            let assignment = CollatorAssignment::collator_container_chain();

1150

1

            assert_eq!(

1151

1

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

1152

1

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

1153

);

1154

1155

1

            assert_eq!(

1156

1

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

1157

1

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

1158

);

1159

1

            assert_eq!(

1160

1

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

1161

1

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

1162

);

1163

1

            assert_eq!(

1164

1

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

1165

1

                Some(1001.into())

1166

);

1167

1

            assert_eq!(

1168

1

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

1169

1

                Some(1001.into())

1170

);

1171

1172

            // Remove BOB

1173

1

            assert_ok!(Invulnerables::remove_invulnerable(

1174

1

                root_origin(),

1175

1

                BOB.into()

1176

));

1177

1178

1

            run_to_session(3u32);

1179

1

            assert_eq!(

1180

1

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

1181

1

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

1182

);

1183

1

            assert_eq!(

1184

1

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

1185

1

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

1186

);

1187

1

            assert_eq!(

1188

1

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

1189

1

                Some(100.into())

1190

);

1191

1

            assert_eq!(

1192

1

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

1193

                None

1194

);

1195

1196

1

            run_to_session(4u32);

1197

1

            assert_eq!(

1198

1

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

1199

1

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

1200

);

1201

1

            assert_eq!(

1202

1

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

1203

1

                Some(vec![])

1204

);

1205

1

            assert_eq!(

1206

1

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

1207

                None

1208

);

1209

1

            assert_eq!(

1210

1

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

1211

                None

1212

);

1213

1

});

1214

1

1215

1216

#[test]

1217

1

fn test_consensus_runtime_api() {

1218

1

    ExtBuilder::default()

1219

1

        .with_balances(vec![

1220

1

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

1221

1

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

1222

1

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

1223

1

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

1224

1

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

1225

1

])

1226

1

        .with_empty_parachains(vec![1001, 1002])

1227

1

        .build()

1228

1

        .execute_with(|| {

1229

1

            run_to_block(2);

1230

1231

1

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

1232

1

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

1233

1234

1

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

1235

1

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

1236

1237

1

            assert_eq!(

1238

1

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

1239

1

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

1240

);

1241

1

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

1242

1

            assert_eq!(

1243

1

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

1244

1

                Some(100.into())

1245

);

1246

1

            assert_eq!(

1247

1

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

1248

1

                Some(100.into())

1249

);

1250

1

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

1251

1

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

1252

1253

            // Set CHARLIE and DAVE keys

1254

1

            assert_ok!(Session::set_keys(

1255

1

                origin_of(CHARLIE.into()),

1256

1

                dancebox_runtime::SessionKeys {

1257

1

                    nimbus: charlie_id.clone(),

1258

1

},

1259

1

                vec![]

1260

));

1261

1

            assert_ok!(Session::set_keys(

1262

1

                origin_of(DAVE.into()),

1263

1

                dancebox_runtime::SessionKeys {

1264

1

                    nimbus: dave_id.clone(),

1265

1

},

1266

1

                vec![]

1267

));

1268

1269

            // Set new invulnerables

1270

1

            assert_ok!(Invulnerables::add_invulnerable(

1271

1

                root_origin(),

1272

1

                CHARLIE.into()

1273

));

1274

1

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

1275

1276

1

            run_to_session(2u32);

1277

1

            assert_eq!(

1278

1

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

1279

1

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

1280

);

1281

1

            assert_eq!(

1282

1

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

1283

1

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

1284

);

1285

1

            assert_eq!(

1286

1

                Runtime::check_para_id_assignment(alice_id),

1287

1

                Some(100.into())

1288

);

1289

1

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

1290

1

            assert_eq!(

1291

1

                Runtime::check_para_id_assignment(charlie_id),

1292

1

                Some(1001.into())

1293

);

1294

1

            assert_eq!(

1295

1

                Runtime::check_para_id_assignment(dave_id),

1296

1

                Some(1001.into())

1297

);

1298

1

});

1299

1

1300

1301

#[test]

1302

1

fn test_consensus_runtime_api_session_changes() {

1303

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

1304

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

1305

    // if we can predict correctly

1306

1

    ExtBuilder::default()

1307

1

        .with_balances(vec![

1308

1

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

1309

1

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

1310

1

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

1311

1

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

1312

1

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

1313

1

])

1314

1

        .with_empty_parachains(vec![1001, 1002])

1315

1

        .build()

1316

1

        .execute_with(|| {

1317

1

            run_to_block(2);

1318

1319

1

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

1320

1

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

1321

1322

1

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

1323

1

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

1324

1325

1

            assert_eq!(

1326

1

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

1327

1

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

1328

);

1329

1

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

1330

1

            assert_eq!(

1331

1

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

1332

1

                Some(100.into())

1333

);

1334

1

            assert_eq!(

1335

1

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

1336

1

                Some(100.into())

1337

);

1338

1

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

1339

1

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

1340

1341

            // Set CHARLIE and DAVE keys

1342

1

            assert_ok!(Session::set_keys(

1343

1

                origin_of(CHARLIE.into()),

1344

1

                dancebox_runtime::SessionKeys {

1345

1

                    nimbus: charlie_id.clone(),

1346

1

},

1347

1

                vec![]

1348

));

1349

1

            assert_ok!(Session::set_keys(

1350

1

                origin_of(DAVE.into()),

1351

1

                dancebox_runtime::SessionKeys {

1352

1

                    nimbus: dave_id.clone(),

1353

1

},

1354

1

                vec![]

1355

));

1356

1357

            // Set new invulnerables

1358

1

            assert_ok!(Invulnerables::add_invulnerable(

1359

1

                root_origin(),

1360

1

                CHARLIE.into()

1361

));

1362

1

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

1363

1364

1

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

1365

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

1366

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

1367

            // edge of a session change

1368

1

            run_to_block(session_two_edge - 2);

1369

1370

1

            assert_eq!(

1371

1

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

1372

1

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

1373

);

1374

1

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

1375

1

            assert_eq!(

1376

1

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

1377

1

                Some(100.into())

1378

);

1379

1

            assert_eq!(

1380

1

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

1381

1

                Some(100.into())

1382

);

1383

1

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

1384

1

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

1385

1386

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

1387

            // authorities of the next block!

1388

1

            run_to_block(session_two_edge - 1);

1389

1

            assert_eq!(

1390

1

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

1391

1

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

1392

);

1393

1

            assert_eq!(

1394

1

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

1395

1

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

1396

);

1397

1

            assert_eq!(

1398

1

                Runtime::check_para_id_assignment(alice_id),

1399

1

                Some(100.into())

1400

);

1401

1

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

1402

1

            assert_eq!(

1403

1

                Runtime::check_para_id_assignment(charlie_id),

1404

1

                Some(1001.into())

1405

);

1406

1

            assert_eq!(

1407

1

                Runtime::check_para_id_assignment(dave_id),

1408

1

                Some(1001.into())

1409

);

1410

1

});

1411

1

1412

1413

#[test]

1414

1

fn test_consensus_runtime_api_next_session() {

1415

1

    ExtBuilder::default()

1416

1

        .with_balances(vec![

1417

1

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

1418

1

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

1419

1

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

1420

1

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

1421

1

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

1422

1

])

1423

1

        .with_empty_parachains(vec![1001, 1002])

1424

1

        .build()

1425

1

        .execute_with(|| {

1426

1

            run_to_block(2);

1427

1428

1

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

1429

1

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

1430

1431

1

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

1432

1

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

1433

1434

1

            assert_eq!(

1435

1

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

1436

1

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

1437

);

1438

1

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

1439

1

            assert_eq!(

1440

1

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

1441

1

                Some(100.into())

1442

);

1443

1

            assert_eq!(

1444

1

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

1445

1

                Some(100.into())

1446

);

1447

1

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

1448

1

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

1449

1450

            // In the next session the assignment will not change

1451

1

            assert_eq!(

1452

1

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

1453

1

                Some(100.into())

1454

);

1455

1

            assert_eq!(

1456

1

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

1457

1

                Some(100.into())

1458

);

1459

1

            assert_eq!(

1460

1

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

1461

                None,

1462

);

1463

1

            assert_eq!(

1464

1

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

1465

                None,

1466

);

1467

1468

            // Set CHARLIE and DAVE keys

1469

1

            assert_ok!(Session::set_keys(

1470

1

                origin_of(CHARLIE.into()),

1471

1

                dancebox_runtime::SessionKeys {

1472

1

                    nimbus: charlie_id.clone(),

1473

1

},

1474

1

                vec![]

1475

));

1476

1

            assert_ok!(Session::set_keys(

1477

1

                origin_of(DAVE.into()),

1478

1

                dancebox_runtime::SessionKeys {

1479

1

                    nimbus: dave_id.clone(),

1480

1

},

1481

1

                vec![]

1482

));

1483

1484

            // Set new invulnerables

1485

1

            assert_ok!(Invulnerables::add_invulnerable(

1486

1

                root_origin(),

1487

1

                CHARLIE.into()

1488

));

1489

1

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

1490

1491

1

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

1492

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

1493

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

1494

            // edge of a session change

1495

1

            run_to_block(session_two_edge - 2);

1496

1497

1

            assert_eq!(

1498

1

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

1499

1

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

1500

);

1501

1

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

1502

1

            assert_eq!(

1503

1

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

1504

1

                Some(100.into())

1505

);

1506

1

            assert_eq!(

1507

1

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

1508

1

                Some(100.into())

1509

);

1510

1

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

1511

1

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

1512

1513

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

1514

1

            assert_eq!(

1515

1

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

1516

1

                Some(100.into())

1517

);

1518

1

            assert_eq!(

1519

1

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

1520

1

                Some(100.into())

1521

);

1522

1

            assert_eq!(

1523

1

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

1524

1

                Some(1001.into()),

1525

);

1526

1

            assert_eq!(

1527

1

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

1528

1

                Some(1001.into()),

1529

);

1530

1531

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

1532

            // authorities of the next block!

1533

1

            run_to_block(session_two_edge - 1);

1534

1

            assert_eq!(

1535

1

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

1536

1

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

1537

);

1538

1

            assert_eq!(

1539

1

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

1540

1

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

1541

);

1542

1

            assert_eq!(

1543

1

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

1544

1

                Some(100.into())

1545

);

1546

1

            assert_eq!(

1547

1

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

1548

1

                Some(100.into())

1549

);

1550

1

            assert_eq!(

1551

1

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

1552

1

                Some(1001.into())

1553

);

1554

1

            assert_eq!(

1555

1

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

1556

1

                Some(1001.into())

1557

);

1558

1559

            // check_para_id_assignment_next_session returns the same value as check_para_id_assignment

1560

            // because we are on a session boundary

1561

1

            assert_eq!(

1562

1

                Runtime::check_para_id_assignment_next_session(alice_id),

1563

1

                Some(100.into())

1564

);

1565

1

            assert_eq!(

1566

1

                Runtime::check_para_id_assignment_next_session(bob_id),

1567

1

                Some(100.into())

1568

);

1569

1

            assert_eq!(

1570

1

                Runtime::check_para_id_assignment_next_session(charlie_id),

1571

1

                Some(1001.into())

1572

);

1573

1

            assert_eq!(

1574

1

                Runtime::check_para_id_assignment_next_session(dave_id),

1575

1

                Some(1001.into())

1576

);

1577

1

});

1578

1

1579

1580

#[test]

1581

1

fn test_author_noting_self_para_id_not_noting() {

1582

1

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

1583

1

        let mut sproof = ParaHeaderSproofBuilder::default();

1584

1

        let slot: u64 = 5;

1585

1

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

1586

1

        let s = ParaHeaderSproofBuilderItem {

1587

1

            para_id: self_para,

1588

1

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

1589

1

                parent_hash: Default::default(),

1590

1

                number: Default::default(),

1591

1

                state_root: Default::default(),

1592

1

                extrinsics_root: Default::default(),

1593

1

                digest: sp_runtime::generic::Digest {

1594

1

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

1595

1

},

1596

1

}),

1597

1

};

1598

1

        sproof.items.push(s);

1599

1600

1

        set_author_noting_inherent_data(sproof);

1601

1602

1

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

1603

1

});

1604

1

1605

1606

#[test]

1607

1

fn test_author_noting_not_self_para() {

1608

1

    ExtBuilder::default()

1609

1

        .with_balances(vec![

1610

1

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

1611

1

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

1612

1

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

1613

1

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

1614

1

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

1615

1

])

1616

1

        .with_collators(vec![

1617

1

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

1618

1

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

1619

1

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

1620

1

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

1621

1

])

1622

1

        .with_empty_parachains(vec![1001, 1002])

1623

1

        .build()

1624

1

        .execute_with(|| {

1625

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1626

1

            let slot: u64 = 5;

1627

1

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

1628

1629

            // Charlie and Dave to 1001

1630

1

            let assignment = CollatorAssignment::collator_container_chain();

1631

1

            assert_eq!(

1632

1

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

1633

1

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

1634

);

1635

1636

1

            let s = ParaHeaderSproofBuilderItem {

1637

1

                para_id: other_para,

1638

1

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

1639

1

                    parent_hash: Default::default(),

1640

1

                    number: 1,

1641

1

                    state_root: Default::default(),

1642

1

                    extrinsics_root: Default::default(),

1643

1

                    digest: sp_runtime::generic::Digest {

1644

1

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

1645

1

},

1646

1

}),

1647

1

};

1648

1

            sproof.items.push(s);

1649

1650

1

            set_author_noting_inherent_data(sproof);

1651

1652

1

            assert_eq!(

1653

1

                AuthorNoting::latest_author(other_para),

1654

1

                Some(ContainerChainBlockInfo {

1655

1

                    block_number: 1,

1656

1

                    author: AccountId::from(DAVE),

1657

1

                    latest_slot_number: 0.into(),

1658

1

})

1659

);

1660

1

});

1661

1

1662

1663

#[test]

1664

1

fn test_author_noting_set_author_and_kill_author_data() {

1665

1

    ExtBuilder::default()

1666

1

        .with_balances(vec![

1667

1

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

1668

1

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

1669

1

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

1670

1

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

1671

1

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

1672

1

])

1673

1

        .with_collators(vec![

1674

1

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

1675

1

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

1676

1

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

1677

1

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

1678

1

])

1679

1

        .with_empty_parachains(vec![1001, 1002])

1680

1

        .build()

1681

1

        .execute_with(|| {

1682

1

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

1683

1684

1

            assert_ok!(AuthorNoting::set_author(

1685

1

                root_origin(),

1686

1

                other_para,

1687

1,

1688

1

                AccountId::from(DAVE),

1689

1

                1.into()

1690

));

1691

1692

1

            assert_eq!(

1693

1

                AuthorNoting::latest_author(other_para),

1694

1

                Some(ContainerChainBlockInfo {

1695

1

                    block_number: 1,

1696

1

                    author: AccountId::from(DAVE),

1697

1

                    latest_slot_number: 1.into(),

1698

1

})

1699

);

1700

1701

1

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

1702

1703

1

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

1704

1

});

1705

1

1706

1707

#[test]

1708

1

fn test_author_noting_set_author_and_kill_author_data_bad_origin() {

1709

1

    ExtBuilder::default()

1710

1

        .with_balances(vec![

1711

1

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

1712

1

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

1713

1

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

1714

1

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

1715

1

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

1716

1

])

1717

1

        .with_collators(vec![

1718

1

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

1719

1

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

1720

1

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

1721

1

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

1722

1

])

1723

1

        .with_empty_parachains(vec![1001, 1002])

1724

1

        .build()

1725

1

        .execute_with(|| {

1726

1

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

1727

1728

1

            assert_noop!(

1729

1

                AuthorNoting::set_author(

1730

1

                    origin_of(ALICE.into()),

1731

1

                    other_para,

1732

1,

1733

1

                    AccountId::from(DAVE),

1734

1

                    1.into()

1735

),

1736

1

                BadOrigin

1737

);

1738

1739

1

            assert_noop!(

1740

1

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

1741

1

                BadOrigin

1742

);

1743

1

});

1744

1

1745

1746

#[test]

1747

1

fn test_author_noting_runtime_api() {

1748

1

    ExtBuilder::default()

1749

1

        .with_balances(vec![

1750

1

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

1751

1

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

1752

1

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

1753

1

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

1754

1

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

1755

1

])

1756

1

        .with_collators(vec![

1757

1

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

1758

1

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

1759

1

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

1760

1

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

1761

1

])

1762

1

        .with_empty_parachains(vec![1001, 1002])

1763

1

        .build()

1764

1

        .execute_with(|| {

1765

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1766

1

            let slot: u64 = 5;

1767

1

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

1768

1769

            // Charlie and Dave to 1001

1770

1

            let assignment = CollatorAssignment::collator_container_chain();

1771

1

            assert_eq!(

1772

1

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

1773

1

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

1774

);

1775

1776

1

            let s = ParaHeaderSproofBuilderItem {

1777

1

                para_id: other_para,

1778

1

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

1779

1

                    parent_hash: Default::default(),

1780

1

                    number: 1,

1781

1

                    state_root: Default::default(),

1782

1

                    extrinsics_root: Default::default(),

1783

1

                    digest: sp_runtime::generic::Digest {

1784

1

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

1785

1

},

1786

1

}),

1787

1

};

1788

1

            sproof.items.push(s);

1789

1790

1

            set_author_noting_inherent_data(sproof);

1791

1792

1

            assert_eq!(

1793

1

                AuthorNoting::latest_author(other_para),

1794

1

                Some(ContainerChainBlockInfo {

1795

1

                    block_number: 1,

1796

1

                    author: AccountId::from(DAVE),

1797

1

                    latest_slot_number: 0.into(),

1798

1

})

1799

);

1800

1801

1

            assert_eq!(

1802

1

                Runtime::latest_author(other_para),

1803

1

                Some(AccountId::from(DAVE))

1804

);

1805

1

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

1806

1

});

1807

1

1808

1809

#[test]

1810

1

fn test_collator_assignment_rotation() {

1811

1

    ExtBuilder::default()

1812

1

        .with_balances(vec![

1813

1

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

1814

1

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

1815

1

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

1816

1

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

1817

1

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

1818

1

])

1819

1

        .with_collators(vec![

1820

1

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

1821

1

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

1822

1

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

1823

1

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

1824

1

])

1825

1

        .with_empty_parachains(vec![1001, 1002])

1826

1

        .build()

1827

1

        .execute_with(|| {

1828

            // Charlie and Dave to 1001

1829

1

            let assignment = CollatorAssignment::collator_container_chain();

1830

1

            let initial_assignment = assignment.clone();

1831

1

            assert_eq!(

1832

1

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

1833

1

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

1834

);

1835

1836

1

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

1837

1

            run_to_session(rotation_period - 2);

1838

1

            set_parachain_inherent_data_random_seed([1; 32]);

1839

1

            run_block();

1840

1841

1

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

1842

1843

1

            run_to_session(rotation_period - 1);

1844

1

            assert_eq!(

1845

1

                CollatorAssignment::collator_container_chain(),

1846

                initial_assignment,

1847

);

1848

1

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

1849

1850

1

            run_to_session(rotation_period);

1851

            // Assignment changed

1852

1

            assert_ne!(

1853

1

                CollatorAssignment::collator_container_chain(),

1854

                initial_assignment,

1855

);

1856

1

});

1857

1

1858

1859

#[test]

1860

1

fn session_keys_key_type_id() {

1861

1

    assert_eq!(

1862

1

        dancebox_runtime::SessionKeys::key_ids(),

1863

1

        vec![NIMBUS_KEY_ID]

1864

);

1865

1

1866

1867

#[test]

1868

1

fn test_session_keys_with_authority_mapping() {

1869

1

    ExtBuilder::default()

1870

1

        .with_balances(vec![

1871

1

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

1872

1

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

1873

1

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

1874

1

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

1875

1

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

1876

1

])

1877

1

        .with_empty_parachains(vec![1001, 1002])

1878

1

        .build()

1879

1

        .execute_with(|| {

1880

1

            run_to_block(2);

1881

1

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

1882

1

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

1883

1

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

1884

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1885

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1886

1887

1

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

1888

1

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

1889

1

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

1890

1891

            // Everything should match to aura

1892

1

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

1893

1894

            // Change Alice and Bob keys to something different

1895

            // for now lets change it to alice_2 and bob_2

1896

1

            assert_ok!(Session::set_keys(

1897

1

                origin_of(ALICE.into()),

1898

1

                dancebox_runtime::SessionKeys {

1899

1

                    nimbus: alice_id_2.clone(),

1900

1

},

1901

1

                vec![]

1902

));

1903

1

            assert_ok!(Session::set_keys(

1904

1

                origin_of(BOB.into()),

1905

1

                dancebox_runtime::SessionKeys {

1906

1

                    nimbus: bob_id_2.clone(),

1907

1

},

1908

1

                vec![]

1909

));

1910

1911

1

            run_to_session(1u32);

1912

1

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

1913

1

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

1914

1

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

1915

1

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

1916

1917

1

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

1918

1

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

1919

1

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

1920

1

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

1921

1922

            // Everything should match to aura

1923

1

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

1924

//

1925

1926

1

            run_to_session(2u32);

1927

1

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

1928

1929

1

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

1930

1

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

1931

1

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

1932

1

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

1933

1934

1

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

1935

1

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

1936

1

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

1937

1

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

1938

1939

            // Everything should match to aura

1940

1

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

1941

1

});

1942

1

1943

1944

#[test]

1945

1

fn test_session_keys_with_authority_assignment() {

1946

1

    ExtBuilder::default()

1947

1

        .with_balances(vec![

1948

1

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

1949

1

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

1950

1

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

1951

1

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

1952

1

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

1953

1

])

1954

1

        .with_empty_parachains(vec![1001, 1002])

1955

1

        .build()

1956

1

        .execute_with(|| {

1957

1

            run_to_block(2);

1958

1

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

1959

1

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

1960

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1961

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1962

1963

1

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

1964

1

            assert_eq!(

1965

                key_mapping_session_0.orchestrator_chain,

1966

1

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

1967

);

1968

1

            assert_eq!(

1969

1

                CollatorAssignment::collator_container_chain().orchestrator_chain,

1970

1

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

1971

);

1972

1973

1

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

1974

1

            assert_eq!(key_mapping_session_1, key_mapping_session_0,);

1975

1

            let old_assignment_session_1 =

1976

1

                CollatorAssignment::pending_collator_container_chain().unwrap();

1977

1

            assert_eq!(

1978

                old_assignment_session_1,

1979

1

                CollatorAssignment::collator_container_chain(),

1980

);

1981

1982

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2);

1983

1

            assert!(key_mapping_session_2.is_none());

1984

1985

            // Everything should match to aura

1986

1

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

1987

1988

            // Change Alice and Bob keys to something different

1989

            // for now lets change it to alice_2 and bob_2

1990

1

            assert_ok!(Session::set_keys(

1991

1

                origin_of(ALICE.into()),

1992

1

                dancebox_runtime::SessionKeys {

1993

1

                    nimbus: alice_id_2.clone(),

1994

1

},

1995

1

                vec![]

1996

));

1997

1

            assert_ok!(Session::set_keys(

1998

1

                origin_of(BOB.into()),

1999

1

                dancebox_runtime::SessionKeys {

2000

1

                    nimbus: bob_id_2.clone(),

2001

1

},

2002

1

                vec![]

2003

));

2004

2005

1

            run_to_session(1u32);

2006

1

            let old_key_mapping_session_1 = key_mapping_session_1;

2007

2008

            // Session 0 got removed

2009

1

            let key_mapping_session_0 = AuthorityAssignment::collator_container_chain(0);

2010

1

            assert!(key_mapping_session_0.is_none());

2011

2012

            // The values at session 1 did not change

2013

1

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

2014

1

            assert_eq!(key_mapping_session_1, old_key_mapping_session_1,);

2015

1

            assert_eq!(

2016

1

                CollatorAssignment::collator_container_chain(),

2017

                old_assignment_session_1,

2018

);

2019

2020

            // Session 2 uses the new keys

2021

1

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

2022

1

            assert_eq!(

2023

                key_mapping_session_2.orchestrator_chain,

2024

1

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

2025

);

2026

1

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

2027

2028

1

            let key_mapping_session_3 = AuthorityAssignment::collator_container_chain(3);

2029

1

            assert!(key_mapping_session_3.is_none());

2030

2031

            // Everything should match to aura

2032

1

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

2033

2034

1

            run_to_session(2u32);

2035

2036

            // Session 1 got removed

2037

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1);

2038

1

            assert!(key_mapping_session_1.is_none());

2039

2040

            // Session 2 uses the new keys

2041

1

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

2042

1

            assert_eq!(

2043

                key_mapping_session_2.orchestrator_chain,

2044

1

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

2045

);

2046

1

            assert_eq!(

2047

                old_assignment_session_1,

2048

1

                CollatorAssignment::collator_container_chain(),

2049

);

2050

2051

            // Session 3 uses the new keys

2052

1

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

2053

1

            assert_eq!(

2054

                key_mapping_session_3.orchestrator_chain,

2055

1

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

2056

);

2057

1

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

2058

2059

1

            let key_mapping_session_4 = AuthorityAssignment::collator_container_chain(4);

2060

1

            assert!(key_mapping_session_4.is_none());

2061

2062

            // Everything should match to aura

2063

1

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

2064

1

});

2065

1

2066

2067

2

fn call_transfer(

2068

2

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

2069

2

    value: u128,

2070

2

) -> RuntimeCall {

2071

2

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

2072

2

2073

2074

#[test]

2075

1

fn test_proxy_any() {

2076

1

    ExtBuilder::default()

2077

1

        .with_balances(vec![

2078

1

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

2079

1

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

2080

1

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

2081

1

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

2082

1

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

2083

1

])

2084

1

        .build()

2085

1

        .execute_with(|| {

2086

1

            run_to_block(2);

2087

2088

1

            let delay = 0;

2089

1

            assert_ok!(Proxy::add_proxy(

2090

1

                origin_of(ALICE.into()),

2091

1

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

2092

1

                ProxyType::Any,

2093

1

                delay

2094

));

2095

2096

1

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

2097

1

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

2098

1

            assert_ok!(Proxy::proxy(

2099

1

                origin_of(BOB.into()),

2100

1

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

2101

1

                None,

2102

1

                call

2103

));

2104

1

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

2105

2106

1

            assert_eq!(balance_after, balance_before + 200_000);

2107

1

});

2108

1

2109

2110

#[test]

2111

1

fn test_proxy_non_transfer() {

2112

1

    ExtBuilder::default()

2113

1

        .with_balances(vec![

2114

1

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

2115

1

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

2116

1

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

2117

1

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

2118

1

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

2119

1

])

2120

1

        .build()

2121

1

        .execute_with(|| {

2122

1

            run_to_block(2);

2123

2124

1

            let delay = 0;

2125

1

            assert_ok!(Proxy::add_proxy(

2126

1

                origin_of(ALICE.into()),

2127

1

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

2128

1

                ProxyType::NonTransfer,

2129

1

                delay

2130

));

2131

2132

1

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

2133

1

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

2134

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

2135

1

            assert_ok!(Proxy::proxy(

2136

1

                origin_of(BOB.into()),

2137

1

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

2138

1

                None,

2139

1

                call

2140

));

2141

1

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

2142

2143

1

            assert_eq!(balance_after, balance_before);

2144

1

});

2145

1

2146

2147

#[test]

2148

1

fn test_proxy_utility() {

2149

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

2150

    // subcalls don't allow to circumvent filters.

2151

2152

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

2153

1

    match ProxyType::Any {

2154

        ProxyType::Any

2155

        | ProxyType::NonTransfer

2156

        | ProxyType::Governance

2157

        | ProxyType::Staking

2158

        | ProxyType::CancelProxy

2159

        | ProxyType::Balances

2160

        | ProxyType::Registrar

2161

        | ProxyType::SudoRegistrar

2162

1

        | ProxyType::SessionKeyManagement => (),

2163

};

2164

2165

    // All except for any

2166

1

    let proxy_types = &[

2167

1

        ProxyType::NonTransfer,

2168

1

        ProxyType::Governance,

2169

1

        ProxyType::Staking,

2170

1

        ProxyType::CancelProxy,

2171

1

        ProxyType::Balances,

2172

1

        ProxyType::Registrar,

2173

1

        ProxyType::SudoRegistrar,

2174

1

        ProxyType::SessionKeyManagement,

2175

1

];

2176

2177

9

    for &proxy_type in proxy_types {

2178

8

        ExtBuilder::default()

2179

8

            .with_balances(vec![

2180

8

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

2181

8

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

2182

8

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

2183

8

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

2184

8

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

2185

8

])

2186

8

            .with_collators(vec![

2187

8

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

2188

8

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

2189

8

])

2190

8

            .with_sudo(AccountId::from(ALICE))

2191

8

            .build()

2192

8

            .execute_with(|| {

2193

8

                assert_ok!(Proxy::add_proxy(

2194

8

                    origin_of(ALICE.into()),

2195

8

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

2196

8

                    proxy_type,

2197

2198

));

2199

2200

8

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

2201

2202

8

                assert_ok!(Proxy::proxy(

2203

8

                    origin_of(BOB.into()),

2204

8

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

2205

8

                    None,

2206

8

                    Box::new(

2207

8

                        pallet_sudo::Call::sudo {

2208

8

                            call: Box::new(

2209

8

                                pallet_utility::Call::batch {

2210

8

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

2211

8

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

2212

8

                                        new_free: 42424242424242

2213

8

2214

8

                                    .into()]

2215

8

2216

8

                                .into()

2217

8

2218

8

2219

8

                        .into()

2220

2221

));

2222

2223

8

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

2224

8

});

2225

2226

1

2227

2228

#[test]

2229

1

fn check_well_known_keys() {

2230

    use frame_support::traits::PalletInfo;

2231

2232

    // Pallet is named "Paras" in Polkadot.

2233

1

    assert_eq!(

2234

        well_known_keys::PARAS_HEADS_INDEX,

2235

1

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

2236

);

2237

2238

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

2239

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

2240

1

    assert_eq!(

2241

1

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

2242

        Some("AuthorityAssignment")

2243

);

2244

1

    assert_eq!(

2245

        well_known_keys::AUTHORITY_ASSIGNMENT_PREFIX,

2246

1

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

2247

);

2248

2249

1

    assert_eq!(

2250

1

        dancebox_runtime::PalletInfo::name::<Session>(),

2251

        Some("Session")

2252

);

2253

1

    assert_eq!(

2254

        well_known_keys::SESSION_INDEX,

2255

1

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

2256

);

2257

1

2258

2259

#[test]

2260

1

fn test_staking_no_candidates_in_genesis() {

2261

1

    ExtBuilder::default()

2262

1

        .with_balances(vec![

2263

1

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

2264

1

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

2265

1

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

2266

1

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

2267

1

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

2268

1

])

2269

1

        .with_collators(vec![

2270

1

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

2271

1

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

2272

1

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

2273

1

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

2274

1

])

2275

1

        .with_empty_parachains(vec![1001, 1002])

2276

1

        .build()

2277

1

        .execute_with(|| {

2278

1

            run_to_block(2);

2279

2280

1

            let initial_candidates =

2281

1

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

2282

2283

1

            assert_eq!(initial_candidates, vec![]);

2284

1

});

2285

1

2286

2287

#[test]

2288

1

fn test_staking_join() {

2289

1

    ExtBuilder::default()

2290

1

        .with_balances(vec![

2291

1

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

2292

1

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

2293

1

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

2294

1

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

2295

1

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

2296

1

])

2297

1

        .with_collators(vec![

2298

1

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

2299

1

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

2300

1

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

2301

1

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

2302

1

])

2303

1

        .with_empty_parachains(vec![1001, 1002])

2304

1

        .build()

2305

1

        .execute_with(|| {

2306

1

            run_to_block(2);

2307

2308

1

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

2309

1

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

2310

1

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

2311

1

            assert_ok!(PooledStaking::request_delegate(

2312

1

                origin_of(ALICE.into()),

2313

1

                ALICE.into(),

2314

1

                ActivePoolKind::AutoCompounding,

2315

1

                stake

2316

));

2317

2318

            // Immediately after joining, Alice is the top candidate

2319

1

            let eligible_candidates =

2320

1

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

2321

1

            assert_eq!(

2322

                eligible_candidates,

2323

1

                vec![EligibleCandidate {

2324

1

                    candidate: ALICE.into(),

2325

1

                    stake

2326

1

}]

2327

);

2328

2329

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

2330

1

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

2331

1

            assert_eq!(balance_before - balance_after, stake);

2332

1

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

2333

1

});

2334

1

2335

2336

#[test]

2337

1

fn test_staking_join_no_keys_registered() {

2338

1

    ExtBuilder::default()

2339

1

        .with_balances(vec![

2340

1

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

2341

1

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

2342

1

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

2343

1

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

2344

1

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

2345

1

])

2346

1

        .with_collators(vec![

2347

1

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

2348

1

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

2349

1

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

2350

1

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

2351

1

])

2352

1

        .with_empty_parachains(vec![

2353

1

            1001,

2354

1

            1002,

2355

1

])

2356

1

2357

1

        .build()

2358

1

        .execute_with(|| {

2359

1

            run_to_block(2);

2360

2361

1

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

2362

1

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

2363

1

            assert_ok!(Balances::transfer_allow_death(

2364

1

                origin_of(ALICE.into()),

2365

1

                new_account.clone().into(),

2366

1

                stake * 2

2367

));

2368

1

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

2369

1

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

2370

1

            assert_ok!(PooledStaking::request_delegate(

2371

1

                origin_of(new_account.clone()),

2372

1

                new_account.clone(),

2373

1

                ActivePoolKind::AutoCompounding,

2374

1

                stake

2375

));

2376

2377

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

2378

            // pallet_session, so it is not eligible

2379

1

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

2380

1

            let eligible_candidates =

2381

1

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

2382

2383

1

            assert_eq!(eligible_candidates, vec![]);

2384

2385

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

2386

1

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

2387

1

            assert_eq!(balance_before - balance_after, stake);

2388

1

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

2389

1

});

2390

1

2391

2392

#[test]

2393

1

fn test_staking_register_keys_after_joining() {

2394

1

    ExtBuilder::default()

2395

1

        .with_balances(vec![

2396

1

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

2397

1

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

2398

1

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

2399

1

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

2400

1

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

2401

1

])

2402

1

        .with_collators(vec![

2403

1

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

2404

1

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

2405

1

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

2406

1

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

2407

1

])

2408

1

        .with_empty_parachains(vec![

2409

1

            1001,

2410

1

            1002,

2411

1

])

2412

1

2413

1

        .build()

2414

1

        .execute_with(|| {

2415

1

            run_to_block(2);

2416

2417

1

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

2418

1

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

2419

1

            assert_ok!(Balances::transfer_allow_death(

2420

1

                origin_of(ALICE.into()),

2421

1

                new_account.clone().into(),

2422

1

                stake * 2

2423

));

2424

1

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

2425

1

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

2426

1

            assert_ok!(PooledStaking::request_delegate(

2427

1

                origin_of(new_account.clone()),

2428

1

                new_account.clone(),

2429

1

                ActivePoolKind::AutoCompounding,

2430

1

                stake

2431

));

2432

2433

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

2434

            // pallet_session, so it is not eligible

2435

1

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

2436

1

            let eligible_candidates =

2437

1

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

2438

1

            assert_eq!(eligible_candidates, vec![]);

2439

2440

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

2441

1

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

2442

1

            assert_eq!(balance_before - balance_after, stake);

2443

1

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

2444

2445

            // Now register the keys

2446

1

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

2447

1

            assert_ok!(Session::set_keys(

2448

1

                origin_of(new_account.clone()),

2449

1

                dancebox_runtime::SessionKeys {

2450

1

                    nimbus: new_account_id,

2451

1

},

2452

1

                vec![]

2453

));

2454

2455

            // Now eligible according to filter

2456

1

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

2457

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

2458

1

            let eligible_candidates =

2459

1

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

2460

1

            assert_eq!(eligible_candidates, vec![]);

2461

2462

            // Update candidate list

2463

1

            assert_ok!(PooledStaking::update_candidate_position(

2464

1

                origin_of(BOB.into()),

2465

1

                vec![new_account.clone()]

2466

));

2467

2468

            // Now it is eligible

2469

1

            let eligible_candidates =

2470

1

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

2471

1

            assert_eq!(

2472

                eligible_candidates,

2473

1

                vec![EligibleCandidate {

2474

1

                    candidate: new_account.clone(),

2475

1

                    stake

2476

1

}]

2477

);

2478

1

});

2479

1

2480

2481

#[test]

2482

1

fn test_staking_join_bad_origin() {

2483

1

    ExtBuilder::default()

2484

1

        .with_balances(vec![

2485

1

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

2486

1

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

2487

1

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

2488

1

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

2489

1

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

2490

1

])

2491

1

        .with_collators(vec![

2492

1

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

2493

1

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

2494

1

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

2495

1

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

2496

1

])

2497

1

        .with_empty_parachains(vec![1001, 1002])

2498

1

        .build()

2499

1

        .execute_with(|| {

2500

1

            run_to_block(2);

2501

2502

1

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

2503

1

            assert_noop!(

2504

1

                PooledStaking::request_delegate(

2505

1

                    root_origin(),

2506

1

                    ALICE.into(),

2507

1

                    ActivePoolKind::AutoCompounding,

2508

1

                    stake

2509

),

2510

1

                BadOrigin,

2511

);

2512

1

});

2513

1

2514

2515

#[test]

2516

1

fn test_staking_join_below_self_delegation_min() {

2517

1

    ExtBuilder::default()

2518

1

        .with_balances(vec![

2519

1

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

2520

1

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

2521

1

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

2522

1

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

2523

1

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

2524

1

])

2525

1

        .with_collators(vec![

2526

1

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

2527

1

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

2528

1

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

2529

1

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

2530

1

])

2531

1

        .with_empty_parachains(vec![1001, 1002])

2532

1

        .build()

2533

1

        .execute_with(|| {

2534

1

            run_to_block(2);

2535

2536

1

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

2537

1

            assert_ok!(PooledStaking::request_delegate(

2538

1

                origin_of(ALICE.into()),

2539

1

                ALICE.into(),

2540

1

                ActivePoolKind::AutoCompounding,

2541

1

                stake1

2542

));

2543

2544

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

2545

            // but the candidate is not eligible

2546

1

            let eligible_candidates =

2547

1

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

2548

1

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

2549

2550

1

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

2551

1

            assert_ok!(PooledStaking::request_delegate(

2552

1

                origin_of(ALICE.into()),

2553

1

                ALICE.into(),

2554

1

                ActivePoolKind::AutoCompounding,

2555

1

                stake2,

2556

));

2557

2558

            // Still below, missing 1 unit

2559

1

            let eligible_candidates =

2560

1

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

2561

1

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

2562

2563

1

            let stake3 = 1;

2564

1

            assert_ok!(PooledStaking::request_delegate(

2565

1

                origin_of(ALICE.into()),

2566

1

                ALICE.into(),

2567

1

                ActivePoolKind::AutoCompounding,

2568

1

                stake3,

2569

));

2570

2571

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

2572

1

            let eligible_candidates =

2573

1

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

2574

1

            assert_eq!(

2575

                eligible_candidates,

2576

1

                vec![EligibleCandidate {

2577

1

                    candidate: ALICE.into(),

2578

1

                    stake: stake1 + stake2 + stake3

2579

1

}],

2580

);

2581

1

});

2582

1

2583

2584

#[test]

2585

1

fn test_staking_join_no_self_delegation() {

2586

1

    ExtBuilder::default()

2587

1

        .with_balances(vec![

2588

1

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

2589

1

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

2590

1

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

2591

1

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

2592

1

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

2593

1

])

2594

1

        .with_collators(vec![

2595

1

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

2596

1

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

2597

1

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

2598

1

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

2599

1

])

2600

1

        .with_empty_parachains(vec![1001, 1002])

2601

1

        .build()

2602

1

        .execute_with(|| {

2603

1

            run_to_block(2);

2604

2605

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

2606

1

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

2607

1

            assert_ok!(PooledStaking::request_delegate(

2608

1

                origin_of(BOB.into()),

2609

1

                ALICE.into(),

2610

1

                ActivePoolKind::AutoCompounding,

2611

1

                stake,

2612

));

2613

2614

1

            let eligible_candidates =

2615

1

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

2616

1

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

2617

1

});

2618

1

2619

2620

#[test]

2621

1

fn test_staking_join_before_self_delegation() {

2622

1

    ExtBuilder::default()

2623

1

        .with_balances(vec![

2624

1

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

2625

1

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

2626

1

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

2627

1

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

2628

1

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

2629

1

])

2630

1

        .with_collators(vec![

2631

1

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

2632

1

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

2633

1

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

2634

1

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

2635

1

])

2636

1

        .with_empty_parachains(vec![1001, 1002])

2637

1

        .build()

2638

1

        .execute_with(|| {

2639

1

            run_to_block(2);

2640

2641

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

2642

1

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

2643

1

            assert_ok!(PooledStaking::request_delegate(

2644

1

                origin_of(BOB.into()),

2645

1

                ALICE.into(),

2646

1

                ActivePoolKind::AutoCompounding,

2647

1

                stake

2648

));

2649

2650

1

            let eligible_candidates =

2651

1

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

2652

1

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

2653

2654

1

            run_to_session(2);

2655

1

            assert_ok!(PooledStaking::execute_pending_operations(

2656

1

                origin_of(ALICE.into()),

2657

1

                vec![PendingOperationQuery {

2658

1

                    delegator: BOB.into(),

2659

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2660

1

                        candidate: ALICE.into(),

2661

1

                        at: 0,

2662

1

2663

1

}]

2664

            ),);

2665

2666

            // Now Alice joins with enough self-delegation

2667

1

            assert_ok!(PooledStaking::request_delegate(

2668

1

                origin_of(ALICE.into()),

2669

1

                ALICE.into(),

2670

1

                ActivePoolKind::AutoCompounding,

2671

1

                stake

2672

));

2673

2674

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

2675

1

            let eligible_candidates =

2676

1

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

2677

1

            assert_eq!(

2678

                eligible_candidates,

2679

1

                vec![EligibleCandidate {

2680

1

                    candidate: ALICE.into(),

2681

1

                    stake: stake * 2,

2682

1

}],

2683

);

2684

1

});

2685

1

2686

2687

#[test]

2688

1

fn test_staking_join_twice_in_same_block() {

2689

1

    ExtBuilder::default()

2690

1

        .with_balances(vec![

2691

1

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

2692

1

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

2693

1

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

2694

1

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

2695

1

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

2696

1

])

2697

1

        .with_collators(vec![

2698

1

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

2699

1

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

2700

1

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

2701

1

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

2702

1

])

2703

1

        .with_empty_parachains(vec![1001, 1002])

2704

1

        .build()

2705

1

        .execute_with(|| {

2706

1

            run_to_block(2);

2707

2708

1

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

2709

1

            assert_ok!(PooledStaking::request_delegate(

2710

1

                origin_of(ALICE.into()),

2711

1

                ALICE.into(),

2712

1

                ActivePoolKind::AutoCompounding,

2713

1

                stake1

2714

));

2715

2716

1

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

2717

1

            assert_ok!(PooledStaking::request_delegate(

2718

1

                origin_of(ALICE.into()),

2719

1

                ALICE.into(),

2720

1

                ActivePoolKind::AutoCompounding,

2721

1

                stake2

2722

));

2723

2724

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

2725

1

            let eligible_candidates =

2726

1

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

2727

2728

1

            assert_eq!(

2729

                eligible_candidates,

2730

1

                vec![EligibleCandidate {

2731

1

                    candidate: ALICE.into(),

2732

1

                    stake: stake1 + stake2,

2733

1

}]

2734

);

2735

2736

1

            run_to_session(2);

2737

2738

1

            assert_ok!(PooledStaking::execute_pending_operations(

2739

1

                origin_of(ALICE.into()),

2740

1

                vec![PendingOperationQuery {

2741

1

                    delegator: ALICE.into(),

2742

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2743

1

                        candidate: ALICE.into(),

2744

1

                        at: 0,

2745

1

2746

1

}]

2747

            ),);

2748

2749

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

2750

1

});

2751

1

2752

2753

#[test]

2754

1

fn test_staking_join_execute_before_time() {

2755

1

    ExtBuilder::default()

2756

1

        .with_balances(vec![

2757

1

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

2758

1

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

2759

1

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

2760

1

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

2761

1

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

2762

1

])

2763

1

        .with_collators(vec![

2764

1

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

2765

1

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

2766

1

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

2767

1

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

2768

1

])

2769

1

        .with_empty_parachains(vec![1001, 1002])

2770

1

        .build()

2771

1

        .execute_with(|| {

2772

1

            run_to_block(2);

2773

2774

1

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

2775

1

            assert_ok!(PooledStaking::request_delegate(

2776

1

                origin_of(ALICE.into()),

2777

1

                ALICE.into(),

2778

1

                ActivePoolKind::AutoCompounding,

2779

1

                stake

2780

));

2781

2782

            // Immediately after joining, Alice is the top candidate

2783

1

            let eligible_candidates =

2784

1

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

2785

1

            assert_eq!(

2786

                eligible_candidates,

2787

1

                vec![EligibleCandidate {

2788

1

                    candidate: ALICE.into(),

2789

1

                    stake

2790

1

}]

2791

);

2792

2793

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

2794

1

            let start_of_session_2 = session_to_block(2);

2795

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

2796

1

            run_to_block(start_of_session_2 - 2);

2797

1

            assert_noop!(

2798

1

                PooledStaking::execute_pending_operations(

2799

1

                    origin_of(ALICE.into()),

2800

1

                    vec![PendingOperationQuery {

2801

1

                        delegator: ALICE.into(),

2802

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

2803

1

                            candidate: ALICE.into(),

2804

1

                            at: 0,

2805

1

2806

1

}]

2807

),

2808

1

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

2809

);

2810

2811

1

            run_to_block(start_of_session_2);

2812

1

            assert_ok!(PooledStaking::execute_pending_operations(

2813

1

                origin_of(ALICE.into()),

2814

1

                vec![PendingOperationQuery {

2815

1

                    delegator: ALICE.into(),

2816

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2817

1

                        candidate: ALICE.into(),

2818

1

                        at: 0,

2819

1

2820

1

}]

2821

            ),);

2822

1

});

2823

1

2824

2825

#[test]

2826

1

fn test_staking_join_execute_any_origin() {

2827

1

    ExtBuilder::default()

2828

1

        .with_balances(vec![

2829

1

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

2830

1

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

2831

1

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

2832

1

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

2833

1

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

2834

1

])

2835

1

        .with_collators(vec![

2836

1

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

2837

1

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

2838

1

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

2839

1

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

2840

1

])

2841

1

        .with_empty_parachains(vec![1001, 1002])

2842

1

        .build()

2843

1

        .execute_with(|| {

2844

1

            run_to_block(2);

2845

2846

1

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

2847

1

            assert_ok!(PooledStaking::request_delegate(

2848

1

                origin_of(ALICE.into()),

2849

1

                ALICE.into(),

2850

1

                ActivePoolKind::AutoCompounding,

2851

1

                stake

2852

));

2853

2854

            // Immediately after joining, Alice is the top candidate

2855

1

            let eligible_candidates =

2856

1

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

2857

1

            assert_eq!(

2858

                eligible_candidates,

2859

1

                vec![EligibleCandidate {

2860

1

                    candidate: ALICE.into(),

2861

1

                    stake

2862

1

}]

2863

);

2864

2865

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

2866

1

            run_to_session(2);

2867

            // Anyone can execute pending operations for anyone else

2868

1

            assert_ok!(PooledStaking::execute_pending_operations(

2869

1

                origin_of(BOB.into()),

2870

1

                vec![PendingOperationQuery {

2871

1

                    delegator: ALICE.into(),

2872

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2873

1

                        candidate: ALICE.into(),

2874

1

                        at: 0,

2875

1

2876

1

}]

2877

            ),);

2878

1

});

2879

1

2880

2881

#[test]

2882

1

fn test_staking_join_execute_bad_origin() {

2883

1

    ExtBuilder::default()

2884

1

        .with_balances(vec![

2885

1

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

2886

1

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

2887

1

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

2888

1

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

2889

1

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

2890

1

])

2891

1

        .with_collators(vec![

2892

1

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

2893

1

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

2894

1

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

2895

1

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

2896

1

])

2897

1

        .with_empty_parachains(vec![1001, 1002])

2898

1

        .build()

2899

1

        .execute_with(|| {

2900

1

            run_to_block(2);

2901

2902

1

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

2903

1

            assert_ok!(PooledStaking::request_delegate(

2904

1

                origin_of(ALICE.into()),

2905

1

                ALICE.into(),

2906

1

                ActivePoolKind::AutoCompounding,

2907

1

                stake

2908

));

2909

2910

            // Immediately after joining, Alice is the top candidate

2911

1

            let eligible_candidates =

2912

1

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

2913

1

            assert_eq!(

2914

                eligible_candidates,

2915

1

                vec![EligibleCandidate {

2916

1

                    candidate: ALICE.into(),

2917

1

                    stake

2918

1

}]

2919

);

2920

2921

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

2922

1

            run_to_session(2);

2923

1

            assert_noop!(

2924

1

                PooledStaking::execute_pending_operations(

2925

1

                    root_origin(),

2926

1

                    vec![PendingOperationQuery {

2927

1

                        delegator: ALICE.into(),

2928

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

2929

1

                            candidate: ALICE.into(),

2930

1

                            at: 0,

2931

1

2932

1

}]

2933

),

2934

1

                BadOrigin,

2935

);

2936

1

});

2937

1

2938

2939

struct A {

2940

    delegator: AccountId,

2941

    candidate: AccountId,

2942

    target_pool: ActivePoolKind,

2943

    stake: u128,

2944

2945

2946

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

2947

9

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

2948

9

    ExtBuilder::default()

2949

9

        .with_balances(vec![

2950

9

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

2951

9

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

2952

9

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

2953

9

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

2954

9

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

2955

9

])

2956

9

        .with_collators(vec![

2957

9

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

2958

9

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

2959

9

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

2960

9

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

2961

9

])

2962

9

        .with_empty_parachains(vec![1001, 1002])

2963

9

        .build()

2964

9

        .execute_with(|| {

2965

9

            run_to_block(2);

2966

2967

9

            for op in ops.iter() {

2968

9

                assert_ok!(PooledStaking::request_delegate(

2969

9

                    origin_of(op.delegator.clone()),

2970

9

                    op.candidate.clone(),

2971

9

                    op.target_pool,

2972

9

                    op.stake,

2973

));

2974

2975

2976

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

2977

9

            run_to_session(2);

2978

2979

9

            for op in ops.iter() {

2980

9

                let operation = match op.target_pool {

2981

                    ActivePoolKind::AutoCompounding => {

2982

9

                        PendingOperationKey::JoiningAutoCompounding {

2983

9

                            candidate: op.candidate.clone(),

2984

9

                            at: 0,

2985

9

2986

2987

                    ActivePoolKind::ManualRewards => PendingOperationKey::JoiningManualRewards {

2988

                        candidate: op.candidate.clone(),

2989

                        at: 0,

2990

},

2991

};

2992

2993

9

                assert_ok!(PooledStaking::execute_pending_operations(

2994

9

                    origin_of(op.delegator.clone()),

2995

9

                    vec![PendingOperationQuery {

2996

9

                        delegator: op.delegator.clone(),

2997

9

                        operation,

2998

9

}]

2999

));

3000

3001

3002

9

f()

3003

9

});

3004

9

3005

3006

#[test]

3007

1

fn test_staking_leave_exact_amount() {

3008

1

    setup_staking_join_and_execute(

3009

1

        vec![A {

3010

1

            delegator: ALICE.into(),

3011

1

            candidate: ALICE.into(),

3012

1

            target_pool: ActivePoolKind::AutoCompounding,

3013

1

            stake: 10 * MinimumSelfDelegation::get(),

3014

1

}],

3015

1

        || {

3016

1

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

3017

1

            assert_ok!(PooledStaking::request_undelegate(

3018

1

                origin_of(ALICE.into()),

3019

1

                ALICE.into(),

3020

1

                ActivePoolKind::AutoCompounding,

3021

1

                SharesOrStake::Stake(stake),

3022

));

3023

3024

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

3025

1

            let eligible_candidates =

3026

1

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

3027

1

            assert_eq!(eligible_candidates, vec![]);

3028

1

},

3029

3030

1

3031

3032

#[test]

3033

1

fn test_staking_leave_bad_origin() {

3034

1

    setup_staking_join_and_execute(

3035

1

        vec![A {

3036

1

            delegator: ALICE.into(),

3037

1

            candidate: ALICE.into(),

3038

1

            target_pool: ActivePoolKind::AutoCompounding,

3039

1

            stake: 10 * MinimumSelfDelegation::get(),

3040

1

}],

3041

1

        || {

3042

1

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

3043

1

            assert_noop!(

3044

1

                PooledStaking::request_undelegate(

3045

1

                    root_origin(),

3046

1

                    ALICE.into(),

3047

1

                    ActivePoolKind::AutoCompounding,

3048

1

                    SharesOrStake::Stake(stake),

3049

),

3050

1

                BadOrigin

3051

);

3052

1

},

3053

3054

1

3055

3056

#[test]

3057

1

fn test_staking_leave_more_than_allowed() {

3058

1

    setup_staking_join_and_execute(

3059

1

        vec![A {

3060

1

            delegator: ALICE.into(),

3061

1

            candidate: ALICE.into(),

3062

1

            target_pool: ActivePoolKind::AutoCompounding,

3063

1

            stake: 10 * MinimumSelfDelegation::get(),

3064

1

}],

3065

1

        || {

3066

1

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

3067

1

            assert_noop!(

3068

1

                PooledStaking::request_undelegate(

3069

1

                    origin_of(ALICE.into()),

3070

1

                    ALICE.into(),

3071

1

                    ActivePoolKind::AutoCompounding,

3072

1

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

3073

),

3074

1

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

3075

);

3076

1

},

3077

);

3078

1

3079

3080

#[test]

3081

1

fn test_staking_leave_in_separate_transactions() {

3082

1

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

3083

3084

1

    setup_staking_join_and_execute(

3085

1

        vec![A {

3086

1

            delegator: ALICE.into(),

3087

1

            candidate: ALICE.into(),

3088

1

            target_pool: ActivePoolKind::AutoCompounding,

3089

1

            stake,

3090

1

}],

3091

1

        || {

3092

1

            let half_stake = stake / 2;

3093

1

            assert_ok!(PooledStaking::request_undelegate(

3094

1

                origin_of(ALICE.into()),

3095

1

                ALICE.into(),

3096

1

                ActivePoolKind::AutoCompounding,

3097

1

                SharesOrStake::Stake(half_stake),

3098

));

3099

3100

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

3101

1

            let eligible_candidates =

3102

1

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

3103

1

            let remaining_stake = stake - half_stake;

3104

1

            assert_eq!(

3105

                eligible_candidates,

3106

1

                vec![EligibleCandidate {

3107

1

                    candidate: ALICE.into(),

3108

1

                    stake: remaining_stake,

3109

1

}],

3110

);

3111

3112

1

            assert_ok!(PooledStaking::request_undelegate(

3113

1

                origin_of(ALICE.into()),

3114

1

                ALICE.into(),

3115

1

                ActivePoolKind::AutoCompounding,

3116

1

                SharesOrStake::Stake(remaining_stake),

3117

));

3118

3119

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

3120

1

            let eligible_candidates =

3121

1

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

3122

1

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

3123

1

},

3124

);

3125

1

3126

3127

#[test]

3128

1

fn test_staking_leave_all_except_some_dust() {

3129

1

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

3130

3131

1

    setup_staking_join_and_execute(

3132

1

        vec![A {

3133

1

            delegator: ALICE.into(),

3134

1

            candidate: ALICE.into(),

3135

1

            target_pool: ActivePoolKind::AutoCompounding,

3136

1

            stake,

3137

1

}],

3138

1

        || {

3139

1

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

3140

1

            assert_ok!(PooledStaking::request_undelegate(

3141

1

                origin_of(ALICE.into()),

3142

1

                ALICE.into(),

3143

1

                ActivePoolKind::AutoCompounding,

3144

1

                SharesOrStake::Stake(stake - dust),

3145

));

3146

3147

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

3148

1

            assert_eq!(

3149

1

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

3150

1

                    AccountId::from(ALICE),

3151

1

                    PoolsKey::CandidateTotalStake

3152

),

3153

                dust,

3154

);

3155

3156

1

            let eligible_candidates =

3157

1

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

3158

1

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

3159

3160

            // Leave with remaining stake

3161

1

            assert_ok!(PooledStaking::request_undelegate(

3162

1

                origin_of(ALICE.into()),

3163

1

                ALICE.into(),

3164

1

                ActivePoolKind::AutoCompounding,

3165

1

                SharesOrStake::Stake(dust),

3166

));

3167

3168

            // Alice has no more stake left

3169

1

            assert_eq!(

3170

1

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

3171

1

                    AccountId::from(ALICE),

3172

1

                    PoolsKey::CandidateTotalStake

3173

),

3174

0,

3175

);

3176

1

},

3177

);

3178

1

3179

3180

#[test]

3181

1

fn test_staking_leave_execute_before_time() {

3182

1

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

3183

3184

1

    setup_staking_join_and_execute(

3185

1

        vec![A {

3186

1

            delegator: ALICE.into(),

3187

1

            candidate: ALICE.into(),

3188

1

            target_pool: ActivePoolKind::AutoCompounding,

3189

1

            stake,

3190

1

}],

3191

1

        || {

3192

1

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

3193

1

            let at = Session::current_index();

3194

1

            assert_ok!(PooledStaking::request_undelegate(

3195

1

                origin_of(ALICE.into()),

3196

1

                ALICE.into(),

3197

1

                ActivePoolKind::AutoCompounding,

3198

1

                SharesOrStake::Stake(stake),

3199

));

3200

3201

            // Request undelegate does not change account balance

3202

1

            assert_eq!(

3203

                balance_before,

3204

1

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

3205

);

3206

3207

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

3208

1

            let start_of_session_4 = session_to_block(4);

3209

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

3210

1

            run_to_block(start_of_session_4 - 2);

3211

3212

1

            assert_noop!(

3213

1

                PooledStaking::execute_pending_operations(

3214

1

                    origin_of(ALICE.into()),

3215

1

                    vec![PendingOperationQuery {

3216

1

                        delegator: ALICE.into(),

3217

1

                        operation: PendingOperationKey::Leaving {

3218

1

                            candidate: ALICE.into(),

3219

1

at,

3220

1

3221

1

}]

3222

),

3223

1

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

3224

);

3225

1

},

3226

);

3227

1

3228

3229

#[test]

3230

1

fn test_staking_leave_execute_any_origin() {

3231

1

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

3232

3233

1

    setup_staking_join_and_execute(

3234

1

        vec![A {

3235

1

            delegator: ALICE.into(),

3236

1

            candidate: ALICE.into(),

3237

1

            target_pool: ActivePoolKind::AutoCompounding,

3238

1

            stake,

3239

1

}],

3240

1

        || {

3241

1

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

3242

1

            let at = Session::current_index();

3243

1

            assert_ok!(PooledStaking::request_undelegate(

3244

1

                origin_of(ALICE.into()),

3245

1

                ALICE.into(),

3246

1

                ActivePoolKind::AutoCompounding,

3247

1

                SharesOrStake::Stake(stake),

3248

));

3249

3250

            // Request undelegate does not change account balance

3251

1

            assert_eq!(

3252

                balance_before,

3253

1

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

3254

);

3255

3256

1

            run_to_session(4);

3257

3258

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

3259

3260

1

            assert_ok!(PooledStaking::execute_pending_operations(

3261

                // Any signed origin can execute this, the stake will go to Alice account

3262

1

                origin_of(BOB.into()),

3263

1

                vec![PendingOperationQuery {

3264

1

                    delegator: ALICE.into(),

3265

1

                    operation: PendingOperationKey::Leaving {

3266

1

                        candidate: ALICE.into(),

3267

1

at,

3268

1

3269

1

}]

3270

            ),);

3271

3272

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

3273

1

            assert_eq!(balance_after - balance_before, stake);

3274

1

},

3275

);

3276

1

3277

3278

#[test]

3279

1

fn test_staking_leave_execute_bad_origin() {

3280

1

    let stake = 10 * MinimumSelfDelegation::get();

3281

3282

1

    setup_staking_join_and_execute(

3283

1

        vec![A {

3284

1

            delegator: ALICE.into(),

3285

1

            candidate: ALICE.into(),

3286

1

            target_pool: ActivePoolKind::AutoCompounding,

3287

1

            stake,

3288

1

}],

3289

1

        || {

3290

1

            let at = Session::current_index();

3291

1

            assert_ok!(PooledStaking::request_undelegate(

3292

1

                origin_of(ALICE.into()),

3293

1

                ALICE.into(),

3294

1

                ActivePoolKind::AutoCompounding,

3295

1

                SharesOrStake::Stake(stake),

3296

));

3297

3298

1

            run_to_session(4);

3299

3300

1

            assert_noop!(

3301

1

                PooledStaking::execute_pending_operations(

3302

1

                    root_origin(),

3303

1

                    vec![PendingOperationQuery {

3304

1

                        delegator: ALICE.into(),

3305

1

                        operation: PendingOperationKey::Leaving {

3306

1

                            candidate: ALICE.into(),

3307

1

at,

3308

1

3309

1

}]

3310

),

3311

1

                BadOrigin

3312

);

3313

1

},

3314

);

3315

1

3316

3317

#[test]

3318

1

fn test_staking_swap() {

3319

1

    setup_staking_join_and_execute(

3320

1

        vec![A {

3321

1

            delegator: ALICE.into(),

3322

1

            candidate: ALICE.into(),

3323

1

            target_pool: ActivePoolKind::AutoCompounding,

3324

1

            stake: 10 * MinimumSelfDelegation::get(),

3325

1

}],

3326

1

        || {

3327

1

            let stake = 10 * MinimumSelfDelegation::get();

3328

1

            assert_ok!(PooledStaking::swap_pool(

3329

1

                origin_of(ALICE.into()),

3330

1

                ALICE.into(),

3331

1

                ActivePoolKind::AutoCompounding,

3332

1

                SharesOrStake::Stake(stake),

3333

));

3334

3335

1

            assert_eq!(

3336

1

                PooledStaking::computed_stake(

3337

1

                    ALICE.into(),

3338

1

                    ALICE.into(),

3339

1

                    PoolKind::AutoCompounding

3340

),

3341

1

                Some(0u32.into())

3342

);

3343

1

            assert_eq!(

3344

1

                PooledStaking::computed_stake(ALICE.into(), ALICE.into(), PoolKind::ManualRewards),

3345

1

                Some(stake)

3346

);

3347

3348

1

            assert_ok!(PooledStaking::swap_pool(

3349

1

                origin_of(ALICE.into()),

3350

1

                ALICE.into(),

3351

1

                ActivePoolKind::ManualRewards,

3352

1

                SharesOrStake::Stake(stake),

3353

));

3354

3355

1

            assert_eq!(

3356

1

                PooledStaking::computed_stake(

3357

1

                    ALICE.into(),

3358

1

                    ALICE.into(),

3359

1

                    PoolKind::AutoCompounding

3360

),

3361

1

                Some(stake)

3362

);

3363

1

            assert_eq!(

3364

1

                PooledStaking::computed_stake(ALICE.into(), ALICE.into(), PoolKind::ManualRewards),

3365

1

                Some(0u32.into())

3366

);

3367

1

},

3368

3369

1

3370

3371

#[test]

3372

1

fn test_pallet_session_takes_validators_from_invulnerables_and_staking() {

3373

    // Alice, Bob, Charlie are invulnerables

3374

    // Alice, Dave are in pallet_staking

3375

    // Expected collators are Alice, Bob, Charlie, Dave

3376

1

    ExtBuilder::default()

3377

1

        .with_balances(vec![

3378

1

            // Alice gets 10k extra tokens for her mapping deposit

3379

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

3380

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

3381

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

3382

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

3383

1

])

3384

1

        .with_collators(vec![

3385

1

            (AccountId::from(ALICE), 210_000_000 * UNIT),

3386

1

            (AccountId::from(BOB), 100_000_000 * UNIT),

3387

1

            (AccountId::from(CHARLIE), 100_000_000 * UNIT),

3388

1

])

3389

1

        .with_empty_parachains(vec![1001, 1002])

3390

1

        .build()

3391

1

        .execute_with(|| {

3392

1

            run_to_block(2);

3393

3394

1

            let stake = 10 * MinimumSelfDelegation::get();

3395

3396

1

            assert_ok!(PooledStaking::request_delegate(

3397

1

                origin_of(ALICE.into()),

3398

1

                ALICE.into(),

3399

1

                ActivePoolKind::AutoCompounding,

3400

1

                stake,

3401

));

3402

3403

            // Register Dave in pallet_session (invulnerables are automatically registered)

3404

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3405

1

            assert_ok!(Session::set_keys(

3406

1

                origin_of(DAVE.into()),

3407

1

                dancebox_runtime::SessionKeys {

3408

1

                    nimbus: dave_account_id,

3409

1

},

3410

1

                vec![]

3411

));

3412

3413

1

            assert_ok!(PooledStaking::request_delegate(

3414

1

                origin_of(DAVE.into()),

3415

1

                DAVE.into(),

3416

1

                ActivePoolKind::AutoCompounding,

3417

1

                stake,

3418

));

3419

3420

1

            let eligible_candidates =

3421

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3422

1

            assert_eq!(

3423

                eligible_candidates,

3424

1

                vec![

3425

1

                    EligibleCandidate {

3426

1

                        candidate: ALICE.into(),

3427

1

                        stake

3428

1

},

3429

1

                    EligibleCandidate {

3430

1

                        candidate: DAVE.into(),

3431

1

                        stake

3432

1

},

3433

3434

);

3435

3436

1

            assert_eq!(

3437

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3438

1

                vec![

3439

1

                    AccountId::from(ALICE),

3440

1

                    AccountId::from(BOB),

3441

1

                    AccountId::from(CHARLIE),

3442

3443

);

3444

3445

            // Need to trigger new session to update pallet_session

3446

1

            run_to_session(2);

3447

3448

1

            assert_eq!(

3449

1

                Session::validators(),

3450

1

                vec![

3451

1

                    AccountId::from(ALICE),

3452

1

                    AccountId::from(BOB),

3453

1

                    AccountId::from(CHARLIE),

3454

1

                    AccountId::from(DAVE),

3455

3456

);

3457

1

});

3458

1

3459

3460

#[test]

3461

1

fn test_pallet_session_limits_num_validators() {

3462

    // Set max_collators = 2, now only the first 2 invulnerables are valid collators

3463

1

    ExtBuilder::default()

3464

1

        .with_balances(vec![

3465

1

            // Alice gets 10k extra tokens for her mapping deposit

3466

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

3467

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

3468

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

3469

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

3470

1

])

3471

1

        .with_collators(vec![

3472

1

            (AccountId::from(ALICE), 210_000_000 * UNIT),

3473

1

            (AccountId::from(BOB), 100_000_000 * UNIT),

3474

1

            (AccountId::from(CHARLIE), 100_000_000 * UNIT),

3475

1

])

3476

1

        .with_empty_parachains(vec![1001, 1002])

3477

1

        .with_config(pallet_configuration::HostConfiguration {

3478

1

            max_collators: 2,

3479

1

            min_orchestrator_collators: 2,

3480

1

            max_orchestrator_collators: 2,

3481

1

            collators_per_container: 2,

3482

1

            full_rotation_period: 24,

3483

1

            ..Default::default()

3484

1

})

3485

1

        .build()

3486

1

        .execute_with(|| {

3487

1

            run_to_block(2);

3488

3489

1

            let stake = 10 * MinimumSelfDelegation::get();

3490

3491

1

            assert_ok!(PooledStaking::request_delegate(

3492

1

                origin_of(ALICE.into()),

3493

1

                ALICE.into(),

3494

1

                ActivePoolKind::AutoCompounding,

3495

1

                stake,

3496

));

3497

3498

            // Register Dave in pallet_session (invulnerables are automatically registered)

3499

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3500

1

            assert_ok!(Session::set_keys(

3501

1

                origin_of(DAVE.into()),

3502

1

                dancebox_runtime::SessionKeys {

3503

1

                    nimbus: dave_account_id,

3504

1

},

3505

1

                vec![]

3506

));

3507

3508

1

            assert_ok!(PooledStaking::request_delegate(

3509

1

                origin_of(DAVE.into()),

3510

1

                DAVE.into(),

3511

1

                ActivePoolKind::AutoCompounding,

3512

1

                stake,

3513

));

3514

3515

1

            let eligible_candidates =

3516

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3517

1

            assert_eq!(

3518

                eligible_candidates,

3519

1

                vec![

3520

1

                    EligibleCandidate {

3521

1

                        candidate: ALICE.into(),

3522

1

                        stake

3523

1

},

3524

1

                    EligibleCandidate {

3525

1

                        candidate: DAVE.into(),

3526

1

                        stake

3527

1

},

3528

3529

);

3530

3531

1

            assert_eq!(

3532

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3533

1

                vec![

3534

1

                    AccountId::from(ALICE),

3535

1

                    AccountId::from(BOB),

3536

1

                    AccountId::from(CHARLIE),

3537

3538

);

3539

3540

            // Need to trigger new session to update pallet_session

3541

1

            run_to_session(2);

3542

3543

1

            assert_eq!(

3544

1

                Session::validators(),

3545

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3546

);

3547

1

});

3548

1

3549

3550

#[test]

3551

1

fn test_pallet_session_limits_num_validators_from_staking() {

3552

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

3553

1

    ExtBuilder::default()

3554

1

        .with_balances(vec![

3555

1

            // Alice gets 10k extra tokens for her mapping deposit

3556

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

3557

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

3558

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

3559

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

3560

1

])

3561

1

        .with_collators(vec![(AccountId::from(ALICE), 210_000_000 * UNIT)])

3562

1

        .with_empty_parachains(vec![1001, 1002])

3563

1

        .with_config(pallet_configuration::HostConfiguration {

3564

1

            max_collators: 2,

3565

1

            min_orchestrator_collators: 2,

3566

1

            max_orchestrator_collators: 2,

3567

1

            collators_per_container: 2,

3568

1

            full_rotation_period: 24,

3569

1

            ..Default::default()

3570

1

})

3571

1

        .build()

3572

1

        .execute_with(|| {

3573

1

            run_to_block(2);

3574

3575

1

            let stake = 10 * MinimumSelfDelegation::get();

3576

3577

            // Register accounts in pallet_session (invulnerables are automatically registered)

3578

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3579

1

            assert_ok!(Session::set_keys(

3580

1

                origin_of(BOB.into()),

3581

1

                dancebox_runtime::SessionKeys {

3582

1

                    nimbus: bob_account_id,

3583

1

},

3584

1

                vec![]

3585

));

3586

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

3587

1

            assert_ok!(Session::set_keys(

3588

1

                origin_of(CHARLIE.into()),

3589

1

                dancebox_runtime::SessionKeys {

3590

1

                    nimbus: charlie_account_id,

3591

1

},

3592

1

                vec![]

3593

));

3594

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3595

1

            assert_ok!(Session::set_keys(

3596

1

                origin_of(DAVE.into()),

3597

1

                dancebox_runtime::SessionKeys {

3598

1

                    nimbus: dave_account_id,

3599

1

},

3600

1

                vec![]

3601

));

3602

3603

1

            assert_ok!(PooledStaking::request_delegate(

3604

1

                origin_of(BOB.into()),

3605

1

                BOB.into(),

3606

1

                ActivePoolKind::AutoCompounding,

3607

1

                stake,

3608

));

3609

3610

1

            assert_ok!(PooledStaking::request_delegate(

3611

1

                origin_of(CHARLIE.into()),

3612

1

                CHARLIE.into(),

3613

1

                ActivePoolKind::AutoCompounding,

3614

1

                stake,

3615

));

3616

3617

1

            assert_ok!(PooledStaking::request_delegate(

3618

1

                origin_of(DAVE.into()),

3619

1

                DAVE.into(),

3620

1

                ActivePoolKind::AutoCompounding,

3621

1

                stake,

3622

));

3623

3624

1

            let eligible_candidates =

3625

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3626

1

            assert_eq!(

3627

                eligible_candidates,

3628

1

                vec![

3629

1

                    EligibleCandidate {

3630

1

                        candidate: BOB.into(),

3631

1

                        stake

3632

1

},

3633

1

                    EligibleCandidate {

3634

1

                        candidate: CHARLIE.into(),

3635

1

                        stake

3636

1

},

3637

1

                    EligibleCandidate {

3638

1

                        candidate: DAVE.into(),

3639

1

                        stake

3640

1

},

3641

3642

);

3643

3644

1

            assert_eq!(

3645

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3646

1

                vec![AccountId::from(ALICE),]

3647

);

3648

3649

            // Need to trigger new session to update pallet_session

3650

1

            run_to_session(2);

3651

3652

1

            assert_eq!(

3653

1

                Session::validators(),

3654

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3655

);

3656

1

});

3657

1

3658

3659

#[test]

3660

1

fn test_reward_to_staking_candidate() {

3661

    // Alice, Bob, Charlie are invulnerables

3662

1

    ExtBuilder::default()

3663

1

        .with_balances(vec![

3664

1

            // Alice gets 10k extra tokens for her mapping deposit

3665

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

3666

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

3667

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

3668

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

3669

1

])

3670

1

        .with_collators(vec![(AccountId::from(ALICE), 210_000_000 * UNIT)])

3671

1

        .with_empty_parachains(vec![1001, 1002])

3672

1

        .build()

3673

1

        .execute_with(|| {

3674

1

            run_to_block(2);

3675

3676

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3677

1

            assert_ok!(Session::set_keys(

3678

1

                origin_of(DAVE.into()),

3679

1

                dancebox_runtime::SessionKeys {

3680

1

                    nimbus: dave_account_id,

3681

1

},

3682

1

                vec![]

3683

));

3684

3685

            // We make delegations to DAVE so that she is an elligible candidate.

3686

3687

1

            let stake = 10 * MinimumSelfDelegation::get();

3688

3689

1

            assert_ok!(PooledStaking::request_delegate(

3690

1

                origin_of(DAVE.into()),

3691

1

                DAVE.into(),

3692

1

                ActivePoolKind::ManualRewards,

3693

1

                stake,

3694

));

3695

1

            assert_ok!(PooledStaking::request_delegate(

3696

1

                origin_of(BOB.into()),

3697

1

                DAVE.into(),

3698

1

                ActivePoolKind::AutoCompounding,

3699

1

                stake,

3700

));

3701

3702

            // wait few sessions for the request to be executable

3703

1

            run_to_session(3u32);

3704

1

            assert_ok!(PooledStaking::execute_pending_operations(

3705

1

                origin_of(ALICE.into()),

3706

1

                vec![

3707

1

                    PendingOperationQuery {

3708

1

                        delegator: DAVE.into(),

3709

1

                        operation: PendingOperationKey::JoiningManualRewards {

3710

1

                            candidate: DAVE.into(),

3711

1

                            at: 0

3712

1

3713

1

},

3714

1

                    PendingOperationQuery {

3715

1

                        delegator: BOB.into(),

3716

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3717

1

                            candidate: DAVE.into(),

3718

1

                            at: 0

3719

1

3720

1

3721

3722

));

3723

3724

            // wait for next session so that DAVE is elected

3725

1

            run_to_session(4u32);

3726

3727

1

            assert_eq!(

3728

1

                Session::validators(),

3729

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

3730

);

3731

3732

1

            let account: AccountId = DAVE.into();

3733

1

            let balance_before = System::account(account.clone()).data.free;

3734

1

            let summary = (0..100)

3735

1

                .find_map(|_| {

3736

1

                    let summary = run_block();

3737

1

                    if summary.author_id == DAVE.into() {

3738

1

                        Some(summary)

3739

                    } else {

3740

                        None

3741

3742

1

})

3743

1

                .unwrap_or_else(|| panic!("DAVE doesn't seem to author any blocks"));

3744

1

            let balance_after = System::account(account).data.free;

3745

3746

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3747

            // rewards are shared between orchestrator and registered paras

3748

1

            let orchestrator_rewards = all_rewards / 3;

3749

1

            let candidate_rewards = RewardsCollatorCommission::get() * orchestrator_rewards;

3750

3751

1

            assert_eq!(

3752

                candidate_rewards,

3753

1

                balance_after - balance_before,

3754

                "dave should get the correct reward portion"

3755

);

3756

1

});

3757

1

3758

3759

#[test]

3760

1

fn test_reward_to_invulnerable() {

3761

    // Alice, Bob, Charlie are invulnerables

3762

1

    ExtBuilder::default()

3763

1

        .with_balances(vec![

3764

1

            // Alice gets 10k extra tokens for her mapping deposit

3765

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3766

1

            (AccountId::from(BOB), 100_000 * UNIT),

3767

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3768

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3769

1

])

3770

1

        .with_collators(vec![

3771

1

            (AccountId::from(ALICE), 210 * UNIT),

3772

1

            (AccountId::from(BOB), 100 * UNIT),

3773

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3774

1

])

3775

1

        .with_empty_parachains(vec![1001, 1002])

3776

1

        .build()

3777

1

        .execute_with(|| {

3778

1

            run_to_block(2);

3779

3780

            // We make delegations to ALICE so that she is an elligible candidate.

3781

            // However since she is an invulnerable she should get all the

3782

            // rewards.

3783

3784

1

            let stake = 10 * MinimumSelfDelegation::get();

3785

3786

1

            assert_ok!(PooledStaking::request_delegate(

3787

1

                origin_of(ALICE.into()),

3788

1

                ALICE.into(),

3789

1

                ActivePoolKind::ManualRewards,

3790

1

                stake,

3791

));

3792

1

            assert_ok!(PooledStaking::request_delegate(

3793

1

                origin_of(BOB.into()),

3794

1

                ALICE.into(),

3795

1

                ActivePoolKind::AutoCompounding,

3796

1

                stake,

3797

));

3798

3799

            // wait few sessions for the request to be executable

3800

1

            run_to_session(3u32);

3801

1

            assert_ok!(PooledStaking::execute_pending_operations(

3802

1

                origin_of(ALICE.into()),

3803

1

                vec![

3804

1

                    PendingOperationQuery {

3805

1

                        delegator: ALICE.into(),

3806

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3807

1

                            candidate: ALICE.into(),

3808

1

                            at: 0

3809

1

3810

1

},

3811

1

                    PendingOperationQuery {

3812

1

                        delegator: BOB.into(),

3813

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3814

1

                            candidate: ALICE.into(),

3815

1

                            at: 0

3816

1

3817

1

3818

3819

));

3820

3821

            // wait for next session so that ALICE is elected

3822

1

            run_to_session(4u32);

3823

3824

1

            let account: AccountId = ALICE.into();

3825

1

            let balance_before = System::account(account.clone()).data.free;

3826

3827

1

            let summary = (0..100)

3828

2

                .find_map(|_| {

3829

2

                    let summary = run_block();

3830

2

                    if summary.author_id == ALICE.into() {

3831

1

                        Some(summary)

3832

                    } else {

3833

1

                        None

3834

3835

2

})

3836

1

                .unwrap_or_else(|| panic!("ALICE doesn't seem to author any blocks"));

3837

3838

1

            let balance_after = System::account(account).data.free;

3839

3840

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3841

            // rewards are shared between orchestrator and registered paras

3842

1

            let orchestrator_rewards = all_rewards / 3;

3843

1

            assert_eq!(

3844

                orchestrator_rewards,

3845

1

                balance_after - balance_before,

3846

                "alice should get the correct reward portion"

3847

);

3848

1

});

3849

1

3850

3851

#[test]

3852

1

fn test_reward_to_invulnerable_with_key_change() {

3853

1

    ExtBuilder::default()

3854

1

        .with_balances(vec![

3855

1

            // Alice gets 10k extra tokens for her mapping deposit

3856

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3857

1

            (AccountId::from(BOB), 100_000 * UNIT),

3858

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3859

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3860

1

])

3861

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3862

1

        .with_empty_parachains(vec![1001, 1002])

3863

1

        .build()

3864

1

        .execute_with(|| {

3865

1

            run_to_block(2);

3866

3867

1

            run_to_session(2u32);

3868

3869

            // change key, this should be reflected 2 sessions afterward

3870

1

            let alice_new_key = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3871

1

            assert_ok!(Session::set_keys(

3872

1

                origin_of(ALICE.into()),

3873

1

                dancebox_runtime::SessionKeys {

3874

1

                    nimbus: alice_new_key,

3875

1

},

3876

1

                vec![]

3877

));

3878

3879

1

            run_to_session(4u32);

3880

3881

1

            let account: AccountId = ALICE.into();

3882

1

            let balance_before = System::account(account.clone()).data.free;

3883

3884

1

            let summary = run_block();

3885

1

            assert_eq!(summary.author_id, ALICE.into());

3886

3887

1

            let balance_after = System::account(account).data.free;

3888

3889

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3890

            // rewards are shared between orchestrator and registered paras

3891

1

            let orchestrator_rewards = all_rewards / 3;

3892

1

            assert_eq!(

3893

                orchestrator_rewards,

3894

1

                balance_after - balance_before,

3895

                "alice should get the correct reward portion"

3896

);

3897

1

});

3898

1

3899

3900

#[test]

3901

1

fn test_migration_config_add_full_rotation_mode() {

3902

1

    ExtBuilder::default().build().execute_with(|| {

3903

        const CONFIGURATION_ACTIVE_CONFIG_KEY: &[u8] =

3904

            &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385");

3905

        const CONFIGURATION_PENDING_CONFIGS_KEY: &[u8] =

3906

            &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22d53b4123b2e186e07fb7bad5dda5f55c0");

3907

3908

        // Modify active config

3909

1

        frame_support::storage::unhashed::put_raw(

3910

1

            CONFIGURATION_ACTIVE_CONFIG_KEY,

3911

1

            &HostConfigurationV3 {

3912

1

                max_collators: 5,

3913

1

                min_orchestrator_collators: 2,

3914

1

                max_orchestrator_collators: 1,

3915

1

                collators_per_container: 3,

3916

1

                full_rotation_period: 4,

3917

1

                collators_per_parathread: 2,

3918

1

                parathreads_per_collator: 1,

3919

1

                target_container_chain_fullness: Perbill::from_percent(45),

3920

1

                max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3921

1

3922

1

            .encode(),

3923

);

3924

        // Modify pending configs

3925

1

        frame_support::storage::unhashed::put_raw(

3926

1

            CONFIGURATION_PENDING_CONFIGS_KEY,

3927

1

            &vec![

3928

1

3929

1

                    1234u32,

3930

1

                    HostConfigurationV3 {

3931

1

                        max_collators: 1,

3932

1

                        min_orchestrator_collators: 4,

3933

1

                        max_orchestrator_collators: 45,

3934

1

                        collators_per_container: 5,

3935

1

                        full_rotation_period: 1,

3936

1

                        collators_per_parathread: 1,

3937

1

                        parathreads_per_collator: 1,

3938

1

                        target_container_chain_fullness: Perbill::from_percent(65),

3939

1

                        max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3940

1

},

3941

1

),

3942

1

3943

1

                    5678u32,

3944

1

                    HostConfigurationV3 {

3945

1

                        max_collators: 1,

3946

1

                        min_orchestrator_collators: 4,

3947

1

                        max_orchestrator_collators: 45,

3948

1

                        collators_per_container: 5,

3949

1

                        full_rotation_period: 1,

3950

1

                        collators_per_parathread: 1,

3951

1

                        parathreads_per_collator: 1,

3952

1

                        target_container_chain_fullness: Perbill::from_percent(65),

3953

1

                        max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3954

1

},

3955

1

),

3956

1

3957

1

            .encode(),

3958

);

3959

3960

1

        let migration = MigrateConfigurationAddFullRotationMode::<Runtime>(Default::default());

3961

1

        migration.migrate(Default::default());

3962

3963

1

        let expected_active = pallet_configuration::HostConfiguration {

3964

1

            max_collators: 5,

3965

1

            min_orchestrator_collators: 2,

3966

1

            max_orchestrator_collators: 1,

3967

1

            collators_per_container: 3,

3968

1

            full_rotation_period: 4,

3969

1

            collators_per_parathread: 2,

3970

1

            parathreads_per_collator: 1,

3971

1

            target_container_chain_fullness: Perbill::from_percent(45),

3972

1

            max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3973

1

            ..Default::default()

3974

1

};

3975

1

        assert_eq!(Configuration::config(), expected_active);

3976

3977

1

        let expected_pending = vec![

3978

1

3979

1

                1234u32,

3980

1

                pallet_configuration::HostConfiguration {

3981

1

                    max_collators: 1,

3982

1

                    min_orchestrator_collators: 4,

3983

1

                    max_orchestrator_collators: 45,

3984

1

                    collators_per_container: 5,

3985

1

                    full_rotation_period: 1,

3986

1

                    collators_per_parathread: 1,

3987

1

                    parathreads_per_collator: 1,

3988

1

                    target_container_chain_fullness: Perbill::from_percent(65),

3989

1

                    max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3990

1

                    ..Default::default()

3991

1

},

3992

1

),

3993

1

3994

1

                5678u32,

3995

1

                pallet_configuration::HostConfiguration {

3996

1

                    max_collators: 1,

3997

1

                    min_orchestrator_collators: 4,

3998

1

                    max_orchestrator_collators: 45,

3999

1

                    collators_per_container: 5,

4000

1

                    full_rotation_period: 1,

4001

1

                    collators_per_parathread: 1,

4002

1

                    parathreads_per_collator: 1,

4003

1

                    target_container_chain_fullness: Perbill::from_percent(65),

4004

1

                    max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

4005

1

                    ..Default::default()

4006

1

},

4007

1

),

4008

];

4009

1

        assert_eq!(Configuration::pending_configs(), expected_pending);

4010

1

});

4011

1

4012

4013

#[test]

4014

1

fn test_migration_registrar_pending_verification() {

4015

1

    ExtBuilder::default().build().execute_with(|| {

4016

        const REGISTRAR_PENDING_VERIFICATION_KEY: &[u8] =

4017

            &hex_literal::hex!("3fba98689ebed1138735e0e7a5a790ab57a35de516113188134ad8e43c6d55ec");

4018

4019

        // Modify active config

4020

1

        let para_ids: Vec<ParaId> = vec![2000.into(), 2001.into(), 2002.into(), 3000.into()];

4021

1

        frame_support::storage::unhashed::put(REGISTRAR_PENDING_VERIFICATION_KEY, &para_ids);

4022

4023

1

        let migration = RegistrarPendingVerificationValueToMap::<Runtime>(Default::default());

4024

1

        migration.migrate(Default::default());

4025

4026

1

        let empty_key =

4027

1

            frame_support::storage::unhashed::get_raw(REGISTRAR_PENDING_VERIFICATION_KEY);

4028

1

        assert_eq!(empty_key, None);

4029

4030

5

        for para_id in para_ids {

4031

4

            let exists_in_map =

4032

4

                pallet_registrar::PendingVerification::<Runtime>::get(para_id).is_some();

4033

4

            assert!(

4034

4

                exists_in_map,

4035

                "After migration, para id {:?} does not exist in storage map",

4036

                para_id

4037

);

4038

4039

1

});

4040

1

4041

4042

#[test]

4043

1

fn test_collator_assignment_gives_priority_to_invulnerables() {

4044

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

4045

1

    ExtBuilder::default()

4046

1

        .with_balances(vec![

4047

1

            // Alice gets 10k extra tokens for her mapping deposit

4048

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

4049

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

4050

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

4051

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

4052

1

])

4053

1

        .with_collators(vec![

4054

1

            (AccountId::from(ALICE), 210_000_000 * UNIT),

4055

1

            (AccountId::from(DAVE), 100_000_000 * UNIT),

4056

1

])

4057

1

        .with_empty_parachains(vec![1001, 1002])

4058

1

        .build()

4059

1

        .execute_with(|| {

4060

1

            run_to_block(2);

4061

4062

1

            let stake = 10 * MinimumSelfDelegation::get();

4063

4064

            // Register accounts in pallet_session (invulnerables are automatically registered)

4065

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4066

1

            assert_ok!(Session::set_keys(

4067

1

                origin_of(BOB.into()),

4068

1

                dancebox_runtime::SessionKeys {

4069

1

                    nimbus: bob_account_id,

4070

1

},

4071

1

                vec![]

4072

));

4073

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

4074

1

            assert_ok!(Session::set_keys(

4075

1

                origin_of(CHARLIE.into()),

4076

1

                dancebox_runtime::SessionKeys {

4077

1

                    nimbus: charlie_account_id,

4078

1

},

4079

1

                vec![]

4080

));

4081

4082

1

            assert_ok!(PooledStaking::request_delegate(

4083

1

                origin_of(BOB.into()),

4084

1

                BOB.into(),

4085

1

                ActivePoolKind::AutoCompounding,

4086

1

                stake,

4087

));

4088

1

            assert_ok!(PooledStaking::request_delegate(

4089

1

                origin_of(CHARLIE.into()),

4090

1

                CHARLIE.into(),

4091

1

                ActivePoolKind::AutoCompounding,

4092

1

                stake,

4093

));

4094

4095

1

            let eligible_candidates =

4096

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

4097

1

            assert_eq!(

4098

                eligible_candidates,

4099

1

                vec![

4100

1

                    EligibleCandidate {

4101

1

                        candidate: BOB.into(),

4102

1

                        stake

4103

1

},

4104

1

                    EligibleCandidate {

4105

1

                        candidate: CHARLIE.into(),

4106

1

                        stake

4107

1

},

4108

4109

);

4110

4111

1

            assert_eq!(

4112

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

4113

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

4114

);

4115

4116

1

            set_parachain_inherent_data_random_seed([1; 32]);

4117

1

            run_block();

4118

4119

            // Need to trigger new session to update pallet_session

4120

1

            run_to_session(2);

4121

4122

1

            assert_eq!(

4123

1

                Session::validators(),

4124

1

                vec![

4125

1

                    AccountId::from(ALICE),

4126

1

                    AccountId::from(DAVE),

4127

1

                    AccountId::from(BOB),

4128

1

                    AccountId::from(CHARLIE)

4129

4130

);

4131

4132

            // Need to trigger full rotation to ensure invulnerables are assigned

4133

1

            let rotation_period = Configuration::config().full_rotation_period;

4134

1

            run_to_session(rotation_period);

4135

4136

1

            assert!(

4137

1

                CollatorAssignment::collator_container_chain()

4138

1

                    .orchestrator_chain

4139

1

                    .contains(&AccountId::from(ALICE)),

4140

                "CollatorAssignment did not give priority to invulnerable ALICE: {:?}",

4141

                CollatorAssignment::collator_container_chain()

4142

);

4143

4144

1

            assert!(

4145

1

                CollatorAssignment::collator_container_chain()

4146

1

                    .orchestrator_chain

4147

1

                    .contains(&AccountId::from(DAVE)),

4148

                "CollatorAssignment did not give priority to invulnerable DAVE: {:?}",

4149

                CollatorAssignment::collator_container_chain()

4150

);

4151

1

});

4152

1

4153

4154

#[test]

4155

1

fn test_can_buy_credits_before_registering_para() {

4156

1

    ExtBuilder::default()

4157

1

        .with_balances(vec![

4158

1

            // Alice gets 10k extra tokens for her mapping deposit

4159

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4160

1

            (AccountId::from(BOB), 100_000 * UNIT),

4161

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4162

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4163

1

])

4164

1

        .with_collators(vec![

4165

1

            (AccountId::from(ALICE), 210 * UNIT),

4166

1

            (AccountId::from(BOB), 100 * UNIT),

4167

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4168

1

            (AccountId::from(DAVE), 100 * UNIT),

4169

1

])

4170

1

        .build()

4171

1

        .execute_with(|| {

4172

1

            run_to_block(2);

4173

4174

            // Try to buy the maximum amount of credits

4175

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4176

4177

1

            assert_ok!(ServicesPayment::purchase_credits(

4178

1

                origin_of(ALICE.into()),

4179

1

                1001.into(),

4180

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4181

));

4182

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4183

4184

            // Now parachain tank should have this amount

4185

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4186

1

                .data

4187

1

                .free;

4188

4189

1

            assert_eq!(

4190

                balance_tank,

4191

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4192

);

4193

4194

1

            let expected_cost = block_credits_to_required_balance(u32::MAX, 1001.into());

4195

1

            assert_eq!(balance_before - balance_after, expected_cost);

4196

1

});

4197

1

4198

4199

#[test]

4200

1

fn test_cannot_mark_valid_para_with_no_bootnodes() {

4201

1

    ExtBuilder::default()

4202

1

        .with_balances(vec![

4203

1

            // Alice gets 10k extra tokens for her mapping deposit

4204

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4205

1

            (AccountId::from(BOB), 100_000 * UNIT),

4206

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4207

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4208

1

])

4209

1

        .with_collators(vec![

4210

1

            (AccountId::from(ALICE), 210 * UNIT),

4211

1

            (AccountId::from(BOB), 100 * UNIT),

4212

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4213

1

            (AccountId::from(DAVE), 100 * UNIT),

4214

1

])

4215

1

        .build()

4216

1

        .execute_with(|| {

4217

1

            run_to_block(2);

4218

1

            assert_ok!(Registrar::register(

4219

1

                origin_of(ALICE.into()),

4220

1

                1001.into(),

4221

1

                empty_genesis_data(),

4222

1

                None

4223

));

4224

1

            assert_noop!(

4225

1

                Registrar::mark_valid_for_collating(root_origin(), 1001.into()),

4226

1

                pallet_data_preservers::Error::<Runtime>::NoBootNodes,

4227

);

4228

1

});

4229

1

4230

4231

#[test]

4232

1

fn test_can_buy_credits_before_registering_para_and_receive_free_credits() {

4233

1

    ExtBuilder::default()

4234

1

        .with_balances(vec![

4235

1

            // Alice gets 10k extra tokens for her mapping deposit

4236

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4237

1

            (AccountId::from(BOB), 100_000 * UNIT),

4238

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4239

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4240

1

])

4241

1

        .with_collators(vec![

4242

1

            (AccountId::from(ALICE), 210 * UNIT),

4243

1

            (AccountId::from(BOB), 100 * UNIT),

4244

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4245

1

            (AccountId::from(DAVE), 100 * UNIT),

4246

1

])

4247

1

        .build()

4248

1

        .execute_with(|| {

4249

1

            run_to_block(2);

4250

4251

            // Try to buy (MaxCreditsStored - 1) credits

4252

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4253

1

            assert_ok!(ServicesPayment::purchase_credits(

4254

1

                origin_of(ALICE.into()),

4255

1

                1001.into(),

4256

1

                block_credits_to_required_balance(

4257

1

                    dancebox_runtime::FreeBlockProductionCredits::get() - 1,

4258

1

                    1001.into()

4259

4260

));

4261

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4262

4263

            // Now parachain tank should have this amount

4264

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4265

1

                .data

4266

1

                .free;

4267

4268

1

            assert_eq!(

4269

                balance_tank,

4270

1

                block_credits_to_required_balance(

4271

1

                    dancebox_runtime::FreeBlockProductionCredits::get() - 1,

4272

1

                    1001.into()

4273

4274

);

4275

4276

1

            let expected_cost = block_credits_to_required_balance(

4277

1

                dancebox_runtime::FreeBlockProductionCredits::get() - 1,

4278

1

                1001.into(),

4279

);

4280

1

            assert_eq!(balance_before - balance_after, expected_cost);

4281

4282

            // Now register para

4283

1

            assert_ok!(Registrar::register(

4284

1

                origin_of(ALICE.into()),

4285

1

                1001.into(),

4286

1

                empty_genesis_data(),

4287

1

                None

4288

));

4289

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4290

1

            assert_ok!(Registrar::mark_valid_for_collating(

4291

1

                root_origin(),

4292

1

                1001.into()

4293

));

4294

4295

            // We received aññ free credits, because we cannot have more than MaxCreditsStored

4296

1

            let credits =

4297

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4298

1

                    .unwrap_or_default();

4299

1

            assert_eq!(credits, dancebox_runtime::FreeBlockProductionCredits::get());

4300

1

});

4301

1

4302

4303

#[test]

4304

1

fn test_deregister_and_register_again_does_not_give_free_credits() {

4305

1

    ExtBuilder::default()

4306

1

        .with_balances(vec![

4307

1

            // Alice gets 10k extra tokens for her mapping deposit

4308

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4309

1

            (AccountId::from(BOB), 100_000 * UNIT),

4310

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4311

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4312

1

])

4313

1

        .with_collators(vec![

4314

1

            (AccountId::from(ALICE), 210 * UNIT),

4315

1

            (AccountId::from(BOB), 100 * UNIT),

4316

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4317

1

            (AccountId::from(DAVE), 100 * UNIT),

4318

1

])

4319

1

        .build()

4320

1

        .execute_with(|| {

4321

1

            run_to_block(2);

4322

4323

            // Register

4324

1

            assert_ok!(Registrar::register(

4325

1

                origin_of(ALICE.into()),

4326

1

                1001.into(),

4327

1

                empty_genesis_data(),

4328

1

                None

4329

            ),);

4330

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4331

1

            assert_ok!(Registrar::mark_valid_for_collating(

4332

1

                root_origin(),

4333

1

                1001.into()

4334

            ),);

4335

            // We received free credits

4336

1

            let credits =

4337

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4338

1

                    .unwrap_or_default();

4339

1

            assert_eq!(credits, dancebox_runtime::FreeBlockProductionCredits::get());

4340

            // Deregister after 1 session

4341

1

            run_to_session(1);

4342

1

            assert_ok!(Registrar::deregister(root_origin(), 1001.into()), ());

4343

4344

1

            run_to_session(3);

4345

1

            let credits_before_2nd_register =

4346

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4347

1

                    .unwrap_or_default();

4348

            // We spent some credits because this container chain had collators for 1 session

4349

1

            assert_ne!(

4350

                credits_before_2nd_register,

4351

1

                dancebox_runtime::FreeBlockProductionCredits::get()

4352

);

4353

            // Register again

4354

1

            assert_ok!(Registrar::register(

4355

1

                origin_of(ALICE.into()),

4356

1

                1001.into(),

4357

1

                empty_genesis_data(),

4358

1

                None

4359

            ),);

4360

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4361

1

            assert_ok!(Registrar::mark_valid_for_collating(

4362

1

                root_origin(),

4363

1

                1001.into()

4364

            ),);

4365

            // No more free credits

4366

1

            let credits =

4367

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4368

1

                    .unwrap_or_default();

4369

1

            assert_eq!(credits, credits_before_2nd_register);

4370

1

});

4371

1

4372

4373

#[test]

4374

1

fn test_sudo_can_register_foreign_assets_and_manager_change_paremeters() {

4375

1

    ExtBuilder::default()

4376

1

        .with_balances(vec![

4377

1

            // Alice gets 10k extra tokens for her mapping deposit

4378

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4379

1

            (AccountId::from(BOB), 100_000 * UNIT),

4380

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4381

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4382

1

])

4383

1

        .with_collators(vec![

4384

1

            (AccountId::from(ALICE), 210 * UNIT),

4385

1

            (AccountId::from(BOB), 100 * UNIT),

4386

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4387

1

            (AccountId::from(DAVE), 100 * UNIT),

4388

1

])

4389

1

4390

1

        .build()

4391

1

        .execute_with(|| {

4392

4393

            // We register the asset with Alice as manager

4394

1

            assert_ok!(ForeignAssetsCreator::create_foreign_asset(root_origin(), Location::parent(), 1, AccountId::from(ALICE), true, 1), ());

4395

1

            assert_eq!(ForeignAssetsCreator::foreign_asset_for_id(1), Some(Location::parent()));

4396

1

            assert_eq!(ForeignAssetsCreator::asset_id_for_foreign(Location::parent()), Some(1));

4397

4398

            // Alice now can change parameters like metadata from the asset

4399

1

            assert_ok!(ForeignAssets::set_metadata(origin_of(ALICE.into()), 1, b"xcDot".to_vec(), b"xcDot".to_vec(), 12));

4400

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::name(1),  b"xcDot".to_vec());

4401

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::symbol(1),  b"xcDot".to_vec());

4402

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::decimals(1),  12);

4403

4404

            // Any other person cannot do this

4405

1

            assert_noop!(

4406

1

                ForeignAssets::set_metadata(origin_of(BOB.into()), 1, b"dummy".to_vec(), b"dummy".to_vec(), 12),

4407

1

                pallet_assets::Error::<Runtime, Instance1>::NoPermission

4408

);

4409

4410

            // Alice now can mint

4411

1

            assert_ok!(ForeignAssets::mint(origin_of(ALICE.into()), 1, AccountId::from(BOB).into(), 1000));

4412

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::total_issuance(1),  1000);

4413

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::balance(1, &AccountId::from(BOB)),  1000);

4414

1

});

4415

1

4416

4417

#[test]

4418

1

fn test_assets_cannot_be_created_from_signed_origins() {

4419

1

    ExtBuilder::default()

4420

1

        .with_balances(vec![

4421

1

            // Alice gets 10k extra tokens for her mapping deposit

4422

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4423

1

            (AccountId::from(BOB), 100_000 * UNIT),

4424

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4425

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4426

1

])

4427

1

        .with_collators(vec![

4428

1

            (AccountId::from(ALICE), 210 * UNIT),

4429

1

            (AccountId::from(BOB), 100 * UNIT),

4430

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4431

1

            (AccountId::from(DAVE), 100 * UNIT),

4432

1

])

4433

1

        .build()

4434

1

        .execute_with(|| {

4435

            // We try to register the asset with Alice as origin

4436

            // Any other person cannot do this

4437

1

            assert_noop!(

4438

1

                ForeignAssetsCreator::create_foreign_asset(

4439

1

                    origin_of(ALICE.into()),

4440

1

                    Location::parent(),

4441

1,

4442

1

                    AccountId::from(ALICE),

4443

                    true,

4444

4445

),

4446

1

                BadOrigin

4447

);

4448

4449

1

            assert_noop!(

4450

1

                ForeignAssets::create(origin_of(ALICE.into()), 1, AccountId::from(ALICE).into(), 1),

4451

1

                BadOrigin

4452

);

4453

1

});

4454

1

4455

4456

#[test]

4457

1

fn test_asset_rate_can_be_set_from_sudo_but_not_from_signed() {

4458

1

    ExtBuilder::default()

4459

1

        .with_balances(vec![

4460

1

            // Alice gets 10k extra tokens for her mapping deposit

4461

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4462

1

            (AccountId::from(BOB), 100_000 * UNIT),

4463

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4464

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4465

1

])

4466

1

        .with_collators(vec![

4467

1

            (AccountId::from(ALICE), 210 * UNIT),

4468

1

            (AccountId::from(BOB), 100 * UNIT),

4469

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4470

1

            (AccountId::from(DAVE), 100 * UNIT),

4471

1

])

4472

1

        .build()

4473

1

        .execute_with(|| {

4474

            // We try to set the rate from non-sudo

4475

1

            assert_noop!(

4476

1

                AssetRate::create(origin_of(ALICE.into()), Box::new(1), FixedU128::from_u32(1)),

4477

1

                BadOrigin

4478

);

4479

4480

            // We try to set the rate from sudo

4481

1

            assert_ok!(AssetRate::create(

4482

1

                root_origin(),

4483

1

                Box::new(1),

4484

1

                FixedU128::from_u32(1)

4485

));

4486

4487

1

            assert_eq!(

4488

1

                pallet_asset_rate::ConversionRateToNative::<Runtime>::get(1),

4489

1

                Some(FixedU128::from_u32(1))

4490

);

4491

1

});

4492

1

4493

4494

#[test]

4495

1

fn test_division_by_0() {

4496

1

    ExtBuilder::default()

4497

1

        .with_balances(vec![

4498

1

            // Alice gets 10k extra tokens for her mapping deposit

4499

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4500

1

            (AccountId::from(BOB), 100_000 * UNIT),

4501

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4502

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4503

1

])

4504

1

        .with_collators(vec![

4505

1

            (AccountId::from(ALICE), 210 * UNIT),

4506

1

            (AccountId::from(BOB), 100 * UNIT),

4507

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4508

1

            (AccountId::from(DAVE), 100 * UNIT),

4509

1

])

4510

1

        .build()

4511

1

        .execute_with(|| {

4512

            // We try to set 0 rate to make sure we dont overflow

4513

1

            assert_ok!(AssetRate::create(

4514

1

                root_origin(),

4515

1

                Box::new(1),

4516

1

                FixedU128::from_u32(0)

4517

));

4518

4519

            use frame_support::traits::tokens::ConversionToAssetBalance;

4520

1

            let balance = AssetRate::to_asset_balance(1, 1);

4521

1

            assert!(balance.is_err());

4522

1

});

4523

1

4524

4525

#[test]

4526

1

fn test_register_parathread() {

4527

1

    ExtBuilder::default()

4528

1

        .with_balances(vec![

4529

1

            // Alice gets 10k extra tokens for her mapping deposit

4530

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4531

1

            (AccountId::from(BOB), 100_000 * UNIT),

4532

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4533

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4534

1

])

4535

1

        .with_collators(vec![

4536

1

            (AccountId::from(ALICE), 210 * UNIT),

4537

1

            (AccountId::from(BOB), 100 * UNIT),

4538

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4539

1

            (AccountId::from(DAVE), 100 * UNIT),

4540

1

])

4541

1

        .build()

4542

1

        .execute_with(|| {

4543

1

            run_to_block(2);

4544

4545

            // Register

4546

1

            assert_ok!(Registrar::register_parathread(

4547

1

                origin_of(ALICE.into()),

4548

1

                3001.into(),

4549

1

                SlotFrequency { min: 1, max: 1 },

4550

1

                empty_genesis_data(),

4551

1

                None

4552

));

4553

1

            set_dummy_boot_node(origin_of(ALICE.into()), 3001.into());

4554

1

            assert_ok!(Registrar::mark_valid_for_collating(

4555

1

                root_origin(),

4556

1

                3001.into()

4557

));

4558

4559

1

            run_to_session(2);

4560

1

            let assignment = CollatorAssignment::collator_container_chain();

4561

1

            assert_eq!(

4562

1

                assignment.container_chains[&ParaId::from(3001)],

4563

1

                vec![CHARLIE.into()]

4564

);

4565

1

});

4566

1

4567

4568

#[test]

4569

1

fn test_register_parathread_genesis() {

4570

1

    let parathread_params = tp_traits::ParathreadParams {

4571

1

        slot_frequency: SlotFrequency { min: 1, max: 1 },

4572

1

};

4573

1

    ExtBuilder::default()

4574

1

        .with_balances(vec![

4575

1

            // Alice gets 10k extra tokens for her mapping deposit

4576

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4577

1

            (AccountId::from(BOB), 100_000 * UNIT),

4578

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4579

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4580

1

])

4581

1

        .with_collators(vec![

4582

1

            (AccountId::from(ALICE), 210 * UNIT),

4583

1

            (AccountId::from(BOB), 100 * UNIT),

4584

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4585

1

            (AccountId::from(DAVE), 100 * UNIT),

4586

1

])

4587

1

        .with_para_ids(vec![ParaRegistrationParams {

4588

1

            para_id: 3001,

4589

1

            genesis_data: empty_genesis_data(),

4590

1

            block_production_credits: u32::MAX,

4591

1

            collator_assignment_credits: u32::MAX,

4592

1

            parathread_params: Some(parathread_params.clone()),

4593

1

}])

4594

1

        .build()

4595

1

        .execute_with(|| {

4596

1

            run_to_block(2);

4597

4598

1

            assert_eq!(Registrar::registered_para_ids(), vec![3001.into()]);

4599

1

            assert_eq!(

4600

1

                pallet_registrar::ParathreadParams::<Runtime>::get(ParaId::from(3001)),

4601

1

                Some(parathread_params)

4602

);

4603

4604

1

            let assignment = CollatorAssignment::collator_container_chain();

4605

1

            assert_eq!(

4606

1

                assignment.container_chains[&ParaId::from(3001)],

4607

1

                vec![CHARLIE.into()]

4608

);

4609

1

});

4610

1

4611

4612

#[test]

4613

1

fn test_ed_plus_block_credit_session_purchase_works() {

4614

1

    ExtBuilder::default()

4615

1

        .with_balances(vec![

4616

1

            // Alice gets 10k extra tokens for her mapping deposit

4617

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4618

1

            (AccountId::from(BOB), 100_000 * UNIT),

4619

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4620

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4621

1

])

4622

1

        .with_collators(vec![

4623

1

            (AccountId::from(ALICE), 210 * UNIT),

4624

1

            (AccountId::from(BOB), 100 * UNIT),

4625

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4626

1

            (AccountId::from(DAVE), 100 * UNIT),

4627

1

])

4628

1

        .build()

4629

1

        .execute_with(|| {

4630

1

            run_to_block(2);

4631

            // Assert current slot gets updated

4632

1

            assert_eq!(current_slot(), 1u64);

4633

1

            assert!(current_author() == AccountId::from(BOB));

4634

4635

            // Alice and Bob collate in our chain

4636

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4637

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4638

4639

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4640

4641

1

            assert_ok!(Registrar::register(

4642

1

                origin_of(ALICE.into()),

4643

1

                1001.into(),

4644

1

                empty_genesis_data(),

4645

1

                None

4646

));

4647

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4648

1

            assert_ok!(Registrar::mark_valid_for_collating(

4649

1

                root_origin(),

4650

1

                1001.into()

4651

));

4652

            // Need to reset credits to 0 because now parachains are given free credits on register

4653

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4654

1

                root_origin(),

4655

1

                1001.into(),

4656

4657

));

4658

1

            let credits_1001 =

4659

1

                block_credits_to_required_balance(dancebox_runtime::Period::get(), 1001.into())

4660

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT;

4661

4662

            // Fill the tank

4663

1

            assert_ok!(ServicesPayment::purchase_credits(

4664

1

                origin_of(ALICE.into()),

4665

1

                1001.into(),

4666

1

                credits_1001

4667

));

4668

4669

            // Assignment should happen after 2 sessions

4670

1

            run_to_session(1u32);

4671

1

            let assignment = CollatorAssignment::collator_container_chain();

4672

1

            assert!(assignment.container_chains.is_empty());

4673

1

            run_to_session(2u32);

4674

            // Charlie and Dave should be assigned to para 1001

4675

1

            let assignment = CollatorAssignment::collator_container_chain();

4676

1

            assert_eq!(

4677

1

                assignment.container_chains[&1001u32.into()],

4678

1

                vec![CHARLIE.into(), DAVE.into()]

4679

);

4680

4681

            // Simulate block inclusion from container chain 1001

4682

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4683

1

            let slot: u64 = 5;

4684

1

            let s = ParaHeaderSproofBuilderItem {

4685

1

                para_id: 1001.into(),

4686

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4687

1

                    parent_hash: Default::default(),

4688

1

                    number: 1,

4689

1

                    state_root: Default::default(),

4690

1

                    extrinsics_root: Default::default(),

4691

1

                    digest: sp_runtime::generic::Digest {

4692

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4693

1

},

4694

1

}),

4695

1

};

4696

4697

1

            sproof.items.push(s);

4698

1

            set_author_noting_inherent_data(sproof);

4699

4700

1

            run_block();

4701

4702

            // After this it should not be assigned anymore, since credits are not payable

4703

1

            run_to_session(3u32);

4704

            // Nobody should be assigned to para 1001

4705

1

            let assignment = CollatorAssignment::collator_container_chain();

4706

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4707

1

});

4708

1

4709

4710

#[test]

4711

1

fn test_ed_plus_block_credit_session_minus_1_purchase_fails() {

4712

1

    ExtBuilder::default()

4713

1

        .with_balances(vec![

4714

1

            // Alice gets 10k extra tokens for her mapping deposit

4715

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4716

1

            (AccountId::from(BOB), 100_000 * UNIT),

4717

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4718

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4719

1

])

4720

1

        .with_collators(vec![

4721

1

            (AccountId::from(ALICE), 210 * UNIT),

4722

1

            (AccountId::from(BOB), 100 * UNIT),

4723

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4724

1

            (AccountId::from(DAVE), 100 * UNIT),

4725

1

])

4726

1

        .build()

4727

1

        .execute_with(|| {

4728

1

            run_to_block(2);

4729

            // Assert current slot gets updated

4730

1

            assert_eq!(current_slot(), 1u64);

4731

1

            assert!(current_author() == AccountId::from(BOB));

4732

4733

            // Alice and Bob collate in our chain

4734

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4735

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4736

4737

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4738

4739

1

            assert_ok!(Registrar::register(

4740

1

                origin_of(ALICE.into()),

4741

1

                1001.into(),

4742

1

                empty_genesis_data(),

4743

1

                None

4744

));

4745

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4746

1

            assert_ok!(Registrar::mark_valid_for_collating(

4747

1

                root_origin(),

4748

1

                1001.into()

4749

));

4750

            // Need to reset credits to 0 because now parachains are given free credits on register

4751

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4752

1

                root_origin(),

4753

1

                1001.into(),

4754

4755

));

4756

1

            let credits_1001 =

4757

1

                block_credits_to_required_balance(dancebox_runtime::Period::get(), 1001.into())

4758

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT

4759

1

                    - 1;

4760

4761

            // Fill the tank

4762

1

            assert_ok!(ServicesPayment::purchase_credits(

4763

1

                origin_of(ALICE.into()),

4764

1

                1001.into(),

4765

1

                credits_1001

4766

));

4767

4768

            // Assignment should happen after 2 sessions

4769

1

            run_to_session(1u32);

4770

1

            let assignment = CollatorAssignment::collator_container_chain();

4771

1

            assert!(assignment.container_chains.is_empty());

4772

1

            run_to_session(2u32);

4773

            // Charlie and Dave should not be assigned to para 1001

4774

1

            let assignment = CollatorAssignment::collator_container_chain();

4775

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4776

1

});

4777

1

4778

4779

#[test]

4780

1

fn test_reassignment_ed_plus_two_block_credit_session_purchase_works() {

4781

1

    ExtBuilder::default()

4782

1

        .with_balances(vec![

4783

1

            // Alice gets 10k extra tokens for her mapping deposit

4784

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4785

1

            (AccountId::from(BOB), 100_000 * UNIT),

4786

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4787

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4788

1

])

4789

1

        .with_collators(vec![

4790

1

            (AccountId::from(ALICE), 210 * UNIT),

4791

1

            (AccountId::from(BOB), 100 * UNIT),

4792

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4793

1

            (AccountId::from(DAVE), 100 * UNIT),

4794

1

])

4795

1

        .build()

4796

1

        .execute_with(|| {

4797

1

            run_to_block(2);

4798

            // Assert current slot gets updated

4799

1

            assert_eq!(current_slot(), 1u64);

4800

1

            assert!(current_author() == AccountId::from(BOB));

4801

4802

            // Alice and Bob collate in our chain

4803

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4804

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4805

4806

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4807

4808

1

            assert_ok!(Registrar::register(

4809

1

                origin_of(ALICE.into()),

4810

1

                1001.into(),

4811

1

                empty_genesis_data(),

4812

1

                None

4813

));

4814

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4815

1

            assert_ok!(Registrar::mark_valid_for_collating(

4816

1

                root_origin(),

4817

1

                1001.into()

4818

));

4819

            // Need to reset credits to 0 because now parachains are given free credits on register

4820

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4821

1

                root_origin(),

4822

1

                1001.into(),

4823

4824

));

4825

            // On reassignment the blocks credits needed should be enough for the current session and the next one

4826

1

            let credits_1001 =

4827

1

                block_credits_to_required_balance(dancebox_runtime::Period::get() * 2, 1001.into())

4828

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT;

4829

4830

            // Fill the tank

4831

1

            assert_ok!(ServicesPayment::purchase_credits(

4832

1

                origin_of(ALICE.into()),

4833

1

                1001.into(),

4834

1

                credits_1001

4835

));

4836

4837

            // Assignment should happen after 2 sessions

4838

1

            run_to_session(1u32);

4839

1

            let assignment = CollatorAssignment::collator_container_chain();

4840

1

            assert!(assignment.container_chains.is_empty());

4841

4842

1

            run_to_session(2u32);

4843

            // Charlie and Dave should be assigned to para 1001

4844

1

            let assignment = CollatorAssignment::collator_container_chain();

4845

1

            assert_eq!(

4846

1

                assignment.container_chains[&1001u32.into()],

4847

1

                vec![CHARLIE.into(), DAVE.into()]

4848

);

4849

4850

            // Simulate block inclusion from container chain 1001

4851

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4852

1

            let slot: u64 = 5;

4853

1

            let s = ParaHeaderSproofBuilderItem {

4854

1

                para_id: 1001.into(),

4855

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4856

1

                    parent_hash: Default::default(),

4857

1

                    number: 1,

4858

1

                    state_root: Default::default(),

4859

1

                    extrinsics_root: Default::default(),

4860

1

                    digest: sp_runtime::generic::Digest {

4861

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4862

1

},

4863

1

}),

4864

1

};

4865

4866

1

            sproof.items.push(s);

4867

1

            set_author_noting_inherent_data(sproof);

4868

4869

1

            run_block();

4870

4871

            // Session 3 should still be assigned

4872

1

            run_to_session(3u32);

4873

            // Charlie and Dave should be assigned to para 1001

4874

1

            let assignment = CollatorAssignment::collator_container_chain();

4875

1

            assert_eq!(

4876

1

                assignment.container_chains[&1001u32.into()],

4877

1

                vec![CHARLIE.into(), DAVE.into()]

4878

);

4879

4880

            // After this it should not be assigned anymore, since credits are not payable

4881

1

            run_to_session(4u32);

4882

            // Nobody should be assigned to para 1001

4883

1

            let assignment = CollatorAssignment::collator_container_chain();

4884

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4885

1

});

4886

1

4887

4888

#[test]

4889

1

fn test_reassignment_ed_plus_two_block_credit_session_minus_1_purchase_fails() {

4890

1

    ExtBuilder::default()

4891

1

        .with_balances(vec![

4892

1

            // Alice gets 10k extra tokens for her mapping deposit

4893

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4894

1

            (AccountId::from(BOB), 100_000 * UNIT),

4895

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4896

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4897

1

])

4898

1

        .with_collators(vec![

4899

1

            (AccountId::from(ALICE), 210 * UNIT),

4900

1

            (AccountId::from(BOB), 100 * UNIT),

4901

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4902

1

            (AccountId::from(DAVE), 100 * UNIT),

4903

1

])

4904

1

        .build()

4905

1

        .execute_with(|| {

4906

1

            run_to_block(2);

4907

            // Assert current slot gets updated

4908

1

            assert_eq!(current_slot(), 1u64);

4909

1

            assert!(current_author() == AccountId::from(BOB));

4910

4911

            // Alice and Bob collate in our chain

4912

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4913

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4914

4915

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4916

4917

1

            assert_ok!(Registrar::register(

4918

1

                origin_of(ALICE.into()),

4919

1

                1001.into(),

4920

1

                empty_genesis_data(),

4921

1

                None

4922

));

4923

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4924

1

            assert_ok!(Registrar::mark_valid_for_collating(

4925

1

                root_origin(),

4926

1

                1001.into()

4927

));

4928

            // Need to reset credits to 0 because now parachains are given free credits on register

4929

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4930

1

                root_origin(),

4931

1

                1001.into(),

4932

4933

));

4934

1

            let credits_1001 =

4935

1

                block_credits_to_required_balance(dancebox_runtime::Period::get() * 2, 1001.into())

4936

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT

4937

1

                    - 1;

4938

4939

            // Fill the tank

4940

1

            assert_ok!(ServicesPayment::purchase_credits(

4941

1

                origin_of(ALICE.into()),

4942

1

                1001.into(),

4943

1

                credits_1001

4944

));

4945

4946

            // Assignment should happen after 2 sessions

4947

1

            run_to_session(1u32);

4948

1

            let assignment = CollatorAssignment::collator_container_chain();

4949

1

            assert!(assignment.container_chains.is_empty());

4950

4951

1

            run_to_session(2u32);

4952

            // Charlie and Dave should be assigned to para 1001

4953

1

            let assignment = CollatorAssignment::collator_container_chain();

4954

1

            assert_eq!(

4955

1

                assignment.container_chains[&1001u32.into()],

4956

1

                vec![CHARLIE.into(), DAVE.into()]

4957

);

4958

4959

            // Simulate block inclusion from container chain 1001

4960

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4961

1

            let slot: u64 = 5;

4962

1

            let s = ParaHeaderSproofBuilderItem {

4963

1

                para_id: 1001.into(),

4964

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4965

1

                    parent_hash: Default::default(),

4966

1

                    number: 1,

4967

1

                    state_root: Default::default(),

4968

1

                    extrinsics_root: Default::default(),

4969

1

                    digest: sp_runtime::generic::Digest {

4970

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4971

1

},

4972

1

}),

4973

1

};

4974

4975

1

            sproof.items.push(s);

4976

1

            set_author_noting_inherent_data(sproof);

4977

4978

1

            run_block();

4979

4980

            // After this it should not be assigned anymore, since credits are not payable

4981

1

            run_to_session(3u32);

4982

            // Nobody should be assigned to para 1001

4983

1

            let assignment = CollatorAssignment::collator_container_chain();

4984

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4985

1

});

4986

1

4987

4988

#[test]

4989

1

fn test_block_credits_with_purchase_can_be_combined() {

4990

1

    ExtBuilder::default()

4991

1

        .with_balances(vec![

4992

1

            // Alice gets 10k extra tokens for her mapping deposit

4993

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4994

1

            (AccountId::from(BOB), 100_000 * UNIT),

4995

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4996

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4997

1

])

4998

1

        .with_collators(vec![

4999

1

            (AccountId::from(ALICE), 210 * UNIT),

5000

1

            (AccountId::from(BOB), 100 * UNIT),

5001

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5002

1

            (AccountId::from(DAVE), 100 * UNIT),

5003

1

])

5004

1

        .build()

5005

1

        .execute_with(|| {

5006

1

            run_to_block(2);

5007

            // Assert current slot gets updated

5008

1

            assert_eq!(current_slot(), 1u64);

5009

1

            assert!(current_author() == AccountId::from(BOB));

5010

5011

            // Alice and Bob collate in our chain

5012

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5013

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5014

5015

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5016

5017

1

            assert_ok!(Registrar::register(

5018

1

                origin_of(ALICE.into()),

5019

1

                1001.into(),

5020

1

                empty_genesis_data(),

5021

1

                None

5022

));

5023

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5024

1

            assert_ok!(Registrar::mark_valid_for_collating(

5025

1

                root_origin(),

5026

1

                1001.into()

5027

));

5028

            // Need to reset credits to 0 because now parachains are given free credits on register

5029

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5030

1

                root_origin(),

5031

1

                1001.into(),

5032

1

                dancebox_runtime::Period::get()

5033

));

5034

1

            let credits_1001 =

5035

1

                block_credits_to_required_balance(dancebox_runtime::Period::get(), 1001.into())

5036

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT;

5037

5038

            // Fill the tank

5039

1

            assert_ok!(ServicesPayment::purchase_credits(

5040

1

                origin_of(ALICE.into()),

5041

1

                1001.into(),

5042

1

                credits_1001

5043

));

5044

5045

            // Assignment should happen after 2 sessions

5046

1

            run_to_session(1u32);

5047

1

            let assignment = CollatorAssignment::collator_container_chain();

5048

1

            assert!(assignment.container_chains.is_empty());

5049

1

            run_to_session(2u32);

5050

            // Charlie and Dave should be assigned to para 1001

5051

1

            let assignment = CollatorAssignment::collator_container_chain();

5052

1

            assert_eq!(

5053

1

                assignment.container_chains[&1001u32.into()],

5054

1

                vec![CHARLIE.into(), DAVE.into()]

5055

);

5056

1

});

5057

1

5058

5059

#[test]

5060

1

fn stream_payment_works() {

5061

1

    ExtBuilder::default()

5062

1

        .with_balances(vec![

5063

1

            (AccountId::from(ALICE), 100_000 * UNIT),

5064

1

            (AccountId::from(BOB), 100_000 * UNIT),

5065

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5066

1

])

5067

1

        .with_collators(vec![

5068

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5069

1

            (AccountId::from(DAVE), 100 * UNIT),

5070

1

])

5071

1

        .build()

5072

1

        .execute_with(|| {

5073

            use pallet_stream_payment::{ChangeKind, StreamConfig};

5074

5075

1

            assert_ok!(StreamPayment::open_stream(

5076

1

                origin_of(ALICE.into()),

5077

1

                BOB.into(),

5078

1

                StreamConfig {

5079

1

                    rate: 2 * UNIT,

5080

1

                    asset_id: StreamPaymentAssetId::Native,

5081

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

5082

1

                    minimum_request_deadline_delay: 0,

5083

1

                    soft_minimum_deposit: 0,

5084

1

},

5085

1

                1_000 * UNIT,

5086

));

5087

5088

1

            run_block();

5089

5090

1

            assert_ok!(StreamPayment::perform_payment(origin_of(CHARLIE.into()), 0));

5091

1

            assert_eq!(

5092

1

                Balances::free_balance(AccountId::from(BOB)),

5093

                100_000 * UNIT + 2 * UNIT

5094

);

5095

5096

1

            assert_ok!(StreamPayment::request_change(

5097

1

                origin_of(ALICE.into()),

5098

0,

5099

1

                ChangeKind::Suggestion,

5100

1

                StreamConfig {

5101

1

                    rate: 1 * UNIT,

5102

1

                    asset_id: StreamPaymentAssetId::Native,

5103

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

5104

1

                    minimum_request_deadline_delay: 0,

5105

1

                    soft_minimum_deposit: 0,

5106

1

},

5107

1

                None,

5108

));

5109

5110

1

            assert_ok!(StreamPayment::accept_requested_change(

5111

1

                origin_of(BOB.into()),

5112

0,

5113

                1, // nonce

5114

1

                None,

5115

));

5116

5117

1

            run_block();

5118

5119

1

            assert_ok!(StreamPayment::close_stream(origin_of(BOB.into()), 0));

5120

5121

1

            assert_eq!(

5122

1

                Balances::free_balance(AccountId::from(BOB)),

5123

                100_000 * UNIT + 3 * UNIT

5124

);

5125

1

            assert_eq!(

5126

1

                Balances::free_balance(AccountId::from(ALICE)),

5127

                100_000 * UNIT - 3 * UNIT

5128

);

5129

1

});

5130

1

5131

5132

#[test]

5133

1

fn test_ed_plus_collator_assignment_session_purchase_works() {

5134

1

    ExtBuilder::default()

5135

1

        .with_balances(vec![

5136

1

            // Alice gets 10k extra tokens for her mapping deposit

5137

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5138

1

            (AccountId::from(BOB), 100_000 * UNIT),

5139

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5140

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5141

1

])

5142

1

        .with_collators(vec![

5143

1

            (AccountId::from(ALICE), 210 * UNIT),

5144

1

            (AccountId::from(BOB), 100 * UNIT),

5145

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5146

1

            (AccountId::from(DAVE), 100 * UNIT),

5147

1

])

5148

1

        .build()

5149

1

        .execute_with(|| {

5150

1

            run_to_block(2);

5151

            // Assert current slot gets updated

5152

1

            assert_eq!(current_slot(), 1u64);

5153

1

            assert!(current_author() == AccountId::from(BOB));

5154

5155

            // Alice and Bob collate in our chain

5156

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5157

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5158

5159

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5160

5161

1

            assert_ok!(Registrar::register(

5162

1

                origin_of(ALICE.into()),

5163

1

                1001.into(),

5164

1

                empty_genesis_data(),

5165

1

                None

5166

));

5167

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5168

1

            assert_ok!(Registrar::mark_valid_for_collating(

5169

1

                root_origin(),

5170

1

                1001.into()

5171

));

5172

            // Need to reset credits to 0 because now parachains are given free credits on register

5173

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5174

1

                root_origin(),

5175

1

                1001.into(),

5176

5177

));

5178

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5179

1

                + dancebox_runtime::EXISTENTIAL_DEPOSIT;

5180

5181

            // Fill the tank

5182

1

            assert_ok!(ServicesPayment::purchase_credits(

5183

1

                origin_of(ALICE.into()),

5184

1

                1001.into(),

5185

1

                credits_1001

5186

));

5187

5188

            // Assignment should happen after 2 sessions

5189

1

            run_to_session(1u32);

5190

1

            let assignment = CollatorAssignment::collator_container_chain();

5191

1

            assert!(assignment.container_chains.is_empty());

5192

1

            run_to_session(2u32);

5193

            // Charlie and Dave should be assigned to para 1001

5194

1

            let assignment = CollatorAssignment::collator_container_chain();

5195

1

            assert_eq!(

5196

1

                assignment.container_chains[&1001u32.into()],

5197

1

                vec![CHARLIE.into(), DAVE.into()]

5198

);

5199

5200

            // Simulate block inclusion from container chain 1001

5201

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

5202

1

            let slot: u64 = 5;

5203

1

            let s = ParaHeaderSproofBuilderItem {

5204

1

                para_id: 1001.into(),

5205

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

5206

1

                    parent_hash: Default::default(),

5207

1

                    number: 1,

5208

1

                    state_root: Default::default(),

5209

1

                    extrinsics_root: Default::default(),

5210

1

                    digest: sp_runtime::generic::Digest {

5211

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

5212

1

},

5213

1

}),

5214

1

};

5215

1

            sproof.items.push(s);

5216

1

            set_author_noting_inherent_data(sproof);

5217

5218

1

            run_block();

5219

5220

            // After this it should not be assigned anymore, since credits are not payable

5221

1

            run_to_session(4u32);

5222

            // Nobody should be assigned to para 1001

5223

1

            let assignment = CollatorAssignment::collator_container_chain();

5224

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5225

1

});

5226

1

5227

5228

#[test]

5229

1

fn test_ed_plus_collator_assignment_credit_session_minus_1_purchase_fails() {

5230

1

    ExtBuilder::default()

5231

1

        .with_balances(vec![

5232

1

            // Alice gets 10k extra tokens for her mapping deposit

5233

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5234

1

            (AccountId::from(BOB), 100_000 * UNIT),

5235

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5236

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5237

1

])

5238

1

        .with_collators(vec![

5239

1

            (AccountId::from(ALICE), 210 * UNIT),

5240

1

            (AccountId::from(BOB), 100 * UNIT),

5241

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5242

1

            (AccountId::from(DAVE), 100 * UNIT),

5243

1

])

5244

1

        .build()

5245

1

        .execute_with(|| {

5246

1

            run_to_block(2);

5247

            // Assert current slot gets updated

5248

1

            assert_eq!(current_slot(), 1u64);

5249

1

            assert!(current_author() == AccountId::from(BOB));

5250

5251

            // Alice and Bob collate in our chain

5252

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5253

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5254

5255

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5256

5257

1

            assert_ok!(Registrar::register(

5258

1

                origin_of(ALICE.into()),

5259

1

                1001.into(),

5260

1

                empty_genesis_data(),

5261

1

                None

5262

));

5263

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5264

1

            assert_ok!(Registrar::mark_valid_for_collating(

5265

1

                root_origin(),

5266

1

                1001.into()

5267

));

5268

            // Need to reset credits to 0 because now parachains are given free credits on register

5269

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5270

1

                root_origin(),

5271

1

                1001.into(),

5272

5273

));

5274

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5275

1

                + dancebox_runtime::EXISTENTIAL_DEPOSIT

5276

1

                - 1;

5277

5278

            // Fill the tank

5279

1

            assert_ok!(ServicesPayment::purchase_credits(

5280

1

                origin_of(ALICE.into()),

5281

1

                1001.into(),

5282

1

                credits_1001

5283

));

5284

5285

            // Assignment should happen after 2 sessions

5286

1

            run_to_session(1u32);

5287

1

            let assignment = CollatorAssignment::collator_container_chain();

5288

1

            assert!(assignment.container_chains.is_empty());

5289

1

            run_to_session(2u32);

5290

            // Charlie and Dave should not be assigned to para 1001

5291

1

            let assignment = CollatorAssignment::collator_container_chain();

5292

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5293

1

});

5294

1

5295

5296

#[test]

5297

1

fn test_collator_assignment_credits_with_purchase_can_be_combined() {

5298

1

    ExtBuilder::default()

5299

1

        .with_balances(vec![

5300

1

            // Alice gets 10k extra tokens for her mapping deposit

5301

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5302

1

            (AccountId::from(BOB), 100_000 * UNIT),

5303

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5304

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5305

1

])

5306

1

        .with_collators(vec![

5307

1

            (AccountId::from(ALICE), 210 * UNIT),

5308

1

            (AccountId::from(BOB), 100 * UNIT),

5309

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5310

1

            (AccountId::from(DAVE), 100 * UNIT),

5311

1

])

5312

1

        .build()

5313

1

        .execute_with(|| {

5314

1

            run_to_block(2);

5315

            // Assert current slot gets updated

5316

1

            assert_eq!(current_slot(), 1u64);

5317

1

            assert!(current_author() == AccountId::from(BOB));

5318

5319

            // Alice and Bob collate in our chain

5320

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5321

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5322

5323

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5324

5325

1

            assert_ok!(Registrar::register(

5326

1

                origin_of(ALICE.into()),

5327

1

                1001.into(),

5328

1

                empty_genesis_data(),

5329

1

                None

5330

));

5331

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5332

1

            assert_ok!(Registrar::mark_valid_for_collating(

5333

1

                root_origin(),

5334

1

                1001.into()

5335

));

5336

5337

            // We assign one session to free credits

5338

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5339

1

                root_origin(),

5340

1

                1001.into(),

5341

5342

));

5343

            // We buy another session through the tank

5344

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5345

1

                + dancebox_runtime::EXISTENTIAL_DEPOSIT;

5346

5347

            // Fill the tank

5348

1

            assert_ok!(ServicesPayment::purchase_credits(

5349

1

                origin_of(ALICE.into()),

5350

1

                1001.into(),

5351

1

                credits_1001

5352

));

5353

5354

            // Assignment should happen after 2 sessions

5355

1

            run_to_session(1u32);

5356

1

            let assignment = CollatorAssignment::collator_container_chain();

5357

1

            assert!(assignment.container_chains.is_empty());

5358

1

            run_to_session(2u32);

5359

            // Charlie and Dave should be assigned to para 1001

5360

1

            let assignment = CollatorAssignment::collator_container_chain();

5361

1

            assert_eq!(

5362

1

                assignment.container_chains[&1001u32.into()],

5363

1

                vec![CHARLIE.into(), DAVE.into()]

5364

);

5365

1

});

5366

1

5367

5368

#[test]

5369

1

fn test_block_credits_and_collator_assignation_credits_through_tank() {

5370

1

    ExtBuilder::default()

5371

1

        .with_balances(vec![

5372

1

            // Alice gets 10k extra tokens for her mapping deposit

5373

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5374

1

            (AccountId::from(BOB), 100_000 * UNIT),

5375

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5376

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5377

1

])

5378

1

        .with_collators(vec![

5379

1

            (AccountId::from(ALICE), 210 * UNIT),

5380

1

            (AccountId::from(BOB), 100 * UNIT),

5381

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5382

1

            (AccountId::from(DAVE), 100 * UNIT),

5383

1

])

5384

1

        .build()

5385

1

        .execute_with(|| {

5386

1

            run_to_block(2);

5387

            // Assert current slot gets updated

5388

1

            assert_eq!(current_slot(), 1u64);

5389

1

            assert!(current_author() == AccountId::from(BOB));

5390

5391

            // Alice and Bob collate in our chain

5392

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5393

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5394

5395

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5396

5397

1

            assert_ok!(Registrar::register(

5398

1

                origin_of(ALICE.into()),

5399

1

                1001.into(),

5400

1

                empty_genesis_data(),

5401

1

                None

5402

));

5403

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5404

1

            assert_ok!(Registrar::mark_valid_for_collating(

5405

1

                root_origin(),

5406

1

                1001.into()

5407

));

5408

5409

            // We make all free credits 0

5410

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5411

1

                root_origin(),

5412

1

                1001.into(),

5413

5414

));

5415

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5416

1

                root_origin(),

5417

1

                1001.into(),

5418

5419

));

5420

5421

            // We buy 2 sessions through tank

5422

1

            let collator_assignation_credits =

5423

1

                collator_assignment_credits_to_required_balance(2, 1001.into());

5424

1

            let block_production_credits =

5425

1

                block_credits_to_required_balance(dancebox_runtime::Period::get() * 2, 1001.into());

5426

5427

            // Fill the tank

5428

1

            assert_ok!(ServicesPayment::purchase_credits(

5429

1

                origin_of(ALICE.into()),

5430

1

                1001.into(),

5431

1

                collator_assignation_credits

5432

1

                    + block_production_credits

5433

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT

5434

));

5435

5436

            // Assignment should happen after 2 sessions

5437

1

            run_to_session(1u32);

5438

1

            let assignment = CollatorAssignment::collator_container_chain();

5439

1

            assert!(assignment.container_chains.is_empty());

5440

1

            run_to_session(2u32);

5441

            // Charlie and Dave should be assigned to para 1001

5442

1

            let assignment = CollatorAssignment::collator_container_chain();

5443

1

            assert_eq!(

5444

1

                assignment.container_chains[&1001u32.into()],

5445

1

                vec![CHARLIE.into(), DAVE.into()]

5446

);

5447

5448

            // After this it should not be assigned anymore, since credits are not payable

5449

1

            run_to_session(4u32);

5450

            // Nobody should be assigned to para 1001

5451

1

            let assignment = CollatorAssignment::collator_container_chain();

5452

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5453

1

});

5454

1

5455

5456

#[test]

5457

1

fn test_migration_services_collator_assignment_payment() {

5458

1

    ExtBuilder::default().build().execute_with(|| {

5459

        // Register a new parachain with no credits

5460

1

        assert_ok!(Registrar::register(

5461

1

            origin_of(ALICE.into()),

5462

1

            1001.into(),

5463

1

            empty_genesis_data(),

5464

1

            None

5465

));

5466

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5467

1

        assert_ok!(Registrar::mark_valid_for_collating(

5468

1

            root_origin(),

5469

1

            1001.into()

5470

));

5471

        // Register another parachain with no credits, do not mark this as valid for collation

5472

1

        assert_ok!(Registrar::register(

5473

1

            origin_of(ALICE.into()),

5474

1

            1002.into(),

5475

1

            empty_genesis_data(),

5476

1

            None

5477

));

5478

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1002.into());

5479

1

        assert_ok!(Registrar::mark_valid_for_collating(

5480

1

            root_origin(),

5481

1

            1002.into()

5482

));

5483

5484

        // Need to reset credits to 0 because now parachains are given free credits on register

5485

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

5486

1

            root_origin(),

5487

1

            1001.into(),

5488

5489

));

5490

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

5491

1

            root_origin(),

5492

1

            1002.into(),

5493

5494

));

5495

5496

1

        let credits_1001 =

5497

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

5498

1

                .unwrap_or_default();

5499

1

        assert_eq!(credits_1001, 0);

5500

1

        let credits_1002 =

5501

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

5502

1

                .unwrap_or_default();

5503

1

        assert_eq!(credits_1002, 0);

5504

5505

        // Apply migration

5506

1

        let migration =

5507

1

            MigrateServicesPaymentAddCollatorAssignmentCredits::<Runtime>(Default::default());

5508

1

        migration.migrate(Default::default());

5509

5510

        // Both parachains have been given credits

5511

1

        let credits_1001 =

5512

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

5513

1

                .unwrap_or_default();

5514

1

        assert_eq!(

5515

            credits_1001,

5516

1

            dancebox_runtime::FreeCollatorAssignmentCredits::get()

5517

);

5518

1

        let credits_1002 =

5519

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

5520

1

                .unwrap_or_default();

5521

1

        assert_eq!(

5522

            credits_1002,

5523

1

            dancebox_runtime::FreeCollatorAssignmentCredits::get()

5524

);

5525

1

});

5526

1

5527

5528

#[test]

5529

1

fn test_max_collators_uses_pending_value() {

5530

    // Start with max_collators = 100, and collators_per_container = 2

5531

    // Set max_collators = 2, and collators_per_container = 3

5532

    // It should be impossible to have more than 2 collators per container at any point in time

5533

1

    ExtBuilder::default()

5534

1

        .with_balances(vec![

5535

1

            // Alice gets 10k extra tokens for her mapping deposit

5536

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5537

1

            (AccountId::from(BOB), 100_000 * UNIT),

5538

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5539

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5540

1

])

5541

1

        .with_collators(vec![

5542

1

            (AccountId::from(ALICE), 210 * UNIT),

5543

1

            (AccountId::from(BOB), 100 * UNIT),

5544

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5545

1

            (AccountId::from(DAVE), 100 * UNIT),

5546

1

])

5547

1

        .with_empty_parachains(vec![1001])

5548

1

        .with_config(pallet_configuration::HostConfiguration {

5549

1

            max_collators: 100,

5550

1

            min_orchestrator_collators: 1,

5551

1

            max_orchestrator_collators: 1,

5552

1

            collators_per_container: 2,

5553

1

            full_rotation_period: 24,

5554

1

            ..Default::default()

5555

1

})

5556

1

        .build()

5557

1

        .execute_with(|| {

5558

1

            run_to_block(2);

5559

5560

            // Initial assignment: 1 collator in orchestrator chain and 2 collators in container 1001

5561

1

            let assignment = CollatorAssignment::collator_container_chain();

5562

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 2);

5563

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5564

5565

1

            assert_ok!(Configuration::set_max_collators(root_origin(), 2));

5566

1

            assert_ok!(Configuration::set_collators_per_container(root_origin(), 3));

5567

5568

            // Check invariant for all intermediate assignments. We set collators_per_container = 3

5569

            // but we also set max_collators = 2, so no collators will be assigned to container

5570

            // chains after the change is applied.

5571

5

            for session in 1..=4 {

5572

4

                run_to_session(session);

5573

5574

4

                let assignment = CollatorAssignment::collator_container_chain();

5575

4

                assert!(

5576

4

                    assignment.container_chains[&1001u32.into()].len() <= 2,

5577

                    "session {}: {} collators assigned to container chain 1001",

5578

                    session,

5579

                    assignment.container_chains[&1001u32.into()].len()

5580

);

5581

5582

5583

            // Final assignment: because max_collators = 2, there are only 2 collators, one in

5584

            // orchestrator chain, and the other one idle

5585

1

            let assignment = CollatorAssignment::collator_container_chain();

5586

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 0);

5587

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5588

1

});

5589

1

5590

5591

#[test]

5592

1

fn test_slow_adjusting_multiplier_changes_in_response_to_consumed_weight() {

5593

1

    ExtBuilder::default()

5594

1

        .with_collators(vec![

5595

1

            (AccountId::from(ALICE), 210 * UNIT),

5596

1

            (AccountId::from(BOB), 100 * UNIT),

5597

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5598

1

            (AccountId::from(DAVE), 100 * UNIT),

5599

1

])

5600

1

        .build()

5601

1

        .execute_with(|| {

5602

1

            end_block();

5603

            // If the block is full, the multiplier increases

5604

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5605

1

            start_block();

5606

1

            let max_block_weights = dancebox_runtime::RuntimeBlockWeights::get();

5607

1

            frame_support::storage::unhashed::put(

5608

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5609

3

                &ConsumedWeight::new(|class| {

5610

3

                    max_block_weights

5611

3

                        .get(class)

5612

3

                        .max_total

5613

3

                        .unwrap_or(Weight::MAX)

5614

3

}),

5615

);

5616

1

            end_block();

5617

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5618

1

            assert!(current_multiplier > before_multiplier);

5619

5620

            // If the block is empty, the multiplier decreases

5621

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5622

1

            start_block();

5623

1

            frame_support::storage::unhashed::put(

5624

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5625

3

                &ConsumedWeight::new(|_class| Weight::zero()),

5626

);

5627

1

            end_block();

5628

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5629

1

            assert!(current_multiplier < before_multiplier);

5630

1

});

5631

1

5632

5633

#[test]

5634

1

fn test_collator_assignment_tip_priority_on_congestion() {

5635

1

    ExtBuilder::default()

5636

1

        .with_balances(vec![

5637

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5638

1

            (AccountId::from(BOB), 100_000 * UNIT),

5639

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5640

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5641

1

])

5642

1

        .with_collators(vec![

5643

1

            (AccountId::from(ALICE), 210 * UNIT),

5644

1

            (AccountId::from(BOB), 100 * UNIT),

5645

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5646

1

            (AccountId::from(DAVE), 100 * UNIT),

5647

1

])

5648

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5649

1

        .build()

5650

1

        .execute_with(|| {

5651

1

            let para_id = 1003u32;

5652

1

            let tank_funds = 100 * UNIT;

5653

1

            let max_tip = 1 * UNIT;

5654

5655

1

            assert_eq!(

5656

1

                CollatorAssignment::collator_container_chain().container_chains[&1003u32.into()]

5657

1

                    .len(),

5658

5659

);

5660

5661

            // Send funds to tank

5662

1

            assert_ok!(ServicesPayment::purchase_credits(

5663

1

                origin_of(ALICE.into()),

5664

1

                para_id.into(),

5665

1

                tank_funds,

5666

));

5667

5668

            // Set tip for 1003

5669

1

            assert_ok!(ServicesPayment::set_max_tip(

5670

1

                root_origin(),

5671

1

                para_id.into(),

5672

1

                Some(max_tip),

5673

));

5674

5675

1

            run_to_session(2);

5676

1

            assert_eq!(

5677

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5678

1

                    .len(),

5679

2,

5680

);

5681

1

});

5682

1

5683

5684

#[test]

5685

1

fn test_collator_assignment_tip_charged_on_congestion() {

5686

1

    ExtBuilder::default()

5687

1

        .with_balances(vec![

5688

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5689

1

            (AccountId::from(BOB), 100_000 * UNIT),

5690

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5691

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5692

1

])

5693

1

        .with_collators(vec![

5694

1

            (AccountId::from(ALICE), 210 * UNIT),

5695

1

            (AccountId::from(BOB), 100 * UNIT),

5696

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5697

1

            (AccountId::from(DAVE), 100 * UNIT),

5698

1

])

5699

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5700

1

        .build()

5701

1

        .execute_with(|| {

5702

1

            let tank_funds = 100 * UNIT;

5703

1

            let max_tip = 1 * UNIT;

5704

1

            let para_id = 1003u32;

5705

5706

            // Send funds to tank

5707

1

            assert_ok!(ServicesPayment::purchase_credits(

5708

1

                origin_of(ALICE.into()),

5709

1

                para_id.into(),

5710

1

                tank_funds,

5711

));

5712

5713

            // Set tip for para_id

5714

1

            assert_ok!(ServicesPayment::set_max_tip(

5715

1

                root_origin(),

5716

1

                para_id.into(),

5717

1

                Some(max_tip),

5718

));

5719

5720

1

            run_to_session(1);

5721

1

            assert_eq!(

5722

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id.into())),

5723

1

                tank_funds - max_tip,

5724

);

5725

1

});

5726

1

5727

5728

#[test]

5729

1

fn test_collator_assignment_tip_not_assigned_on_insufficient_balance() {

5730

1

    ExtBuilder::default()

5731

1

        .with_balances(vec![

5732

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5733

1

            (AccountId::from(BOB), 100_000 * UNIT),

5734

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5735

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5736

1

])

5737

1

        .with_collators(vec![

5738

1

            (AccountId::from(ALICE), 210 * UNIT),

5739

1

            (AccountId::from(BOB), 100 * UNIT),

5740

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5741

1

            (AccountId::from(DAVE), 100 * UNIT),

5742

1

])

5743

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5744

1

        .build()

5745

1

        .execute_with(|| {

5746

1

            let tank_funds = 1 * UNIT;

5747

1

            let max_tip = 1 * UNIT;

5748

1

            let para_id = 1003u32;

5749

5750

            // Send insufficient funds to tank for tip for 2 sessions

5751

1

            assert_ok!(ServicesPayment::purchase_credits(

5752

1

                origin_of(ALICE.into()),

5753

1

                para_id.into(),

5754

1

                tank_funds,

5755

));

5756

5757

            // Set tip for para_id

5758

1

            assert_ok!(ServicesPayment::set_max_tip(

5759

1

                root_origin(),

5760

1

                para_id.into(),

5761

1

                Some(max_tip),

5762

));

5763

5764

1

            run_to_session(1);

5765

1

            assert_eq!(

5766

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5767

1

                    .len(),

5768

5769

);

5770

1

});

5771

1

5772

5773

#[test]

5774

1

fn test_collator_assignment_tip_only_charge_willing_paras() {

5775

1

    ExtBuilder::default()

5776

1

        .with_balances(vec![

5777

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5778

1

            (AccountId::from(BOB), 100_000 * UNIT),

5779

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5780

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5781

1

            (AccountId::from(EVE), 100_000 * UNIT),

5782

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5783

1

])

5784

1

        .with_collators(vec![

5785

1

            (AccountId::from(ALICE), 210 * UNIT),

5786

1

            (AccountId::from(BOB), 100 * UNIT),

5787

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5788

1

            (AccountId::from(DAVE), 100 * UNIT),

5789

1

            (AccountId::from(EVE), 100 * UNIT),

5790

1

            (AccountId::from(FERDIE), 100 * UNIT),

5791

1

])

5792

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5793

1

        .build()

5794

1

        .execute_with(|| {

5795

1

            let tank_funds = 100 * UNIT;

5796

1

            let max_tip = 1 * UNIT;

5797

1

            let para_id_with_tip = 1003u32;

5798

1

            let para_id_without_tip = 1001u32;

5799

5800

            // Send funds to tank to both paras

5801

1

            assert_ok!(ServicesPayment::purchase_credits(

5802

1

                origin_of(ALICE.into()),

5803

1

                para_id_with_tip.into(),

5804

1

                tank_funds,

5805

));

5806

1

            assert_ok!(ServicesPayment::purchase_credits(

5807

1

                origin_of(ALICE.into()),

5808

1

                para_id_without_tip.into(),

5809

1

                tank_funds,

5810

));

5811

5812

            // Only set tip for 1003

5813

1

            assert_ok!(ServicesPayment::set_max_tip(

5814

1

                root_origin(),

5815

1

                para_id_with_tip.into(),

5816

1

                Some(max_tip),

5817

));

5818

5819

1

            run_to_session(2);

5820

5821

1

            let assignment = CollatorAssignment::collator_container_chain().container_chains;

5822

5823

            // 2 out of the 3 paras should have collators assigned, with one paying tip to get

5824

            // prioritized, and the other selected at random that should not be charged any tips

5825

1

            assert_eq!(assignment[&para_id_with_tip.into()].len(), 2);

5826

1

            assert_eq!(

5827

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_with_tip.into())),

5828

1

                tank_funds - max_tip * 2,

5829

);

5830

5831

1

            assert_eq!(assignment[&para_id_without_tip.into()].len(), 2);

5832

1

            assert_eq!(

5833

1

                Balances::usable_balance(ServicesPayment::parachain_tank(

5834

1

                    para_id_without_tip.into()

5835

)),

5836

                tank_funds,

5837

);

5838

1

});

5839

1

5840

5841

#[test]

5842

1

fn test_collator_assignment_tip_withdraw_min_tip() {

5843

1

    ExtBuilder::default()

5844

1

        .with_balances(vec![

5845

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5846

1

            (AccountId::from(BOB), 100_000 * UNIT),

5847

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5848

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5849

1

            (AccountId::from(EVE), 100_000 * UNIT),

5850

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5851

1

])

5852

1

        .with_collators(vec![

5853

1

            (AccountId::from(ALICE), 210 * UNIT),

5854

1

            (AccountId::from(BOB), 100 * UNIT),

5855

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5856

1

            (AccountId::from(DAVE), 100 * UNIT),

5857

1

            (AccountId::from(EVE), 100 * UNIT),

5858

1

            (AccountId::from(FERDIE), 100 * UNIT),

5859

1

])

5860

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5861

1

        .build()

5862

1

        .execute_with(|| {

5863

1

            let tank_funds = 100 * UNIT;

5864

1

            let max_tip_1003 = 3 * UNIT;

5865

1

            let max_tip_1002 = 2 * UNIT;

5866

1

            let para_id_1003 = 1003u32;

5867

1

            let para_id_1002 = 1002u32;

5868

5869

            // Send funds to tank to both paras

5870

1

            assert_ok!(ServicesPayment::purchase_credits(

5871

1

                origin_of(ALICE.into()),

5872

1

                para_id_1003.into(),

5873

1

                tank_funds,

5874

));

5875

1

            assert_ok!(ServicesPayment::purchase_credits(

5876

1

                origin_of(ALICE.into()),

5877

1

                para_id_1002.into(),

5878

1

                tank_funds,

5879

));

5880

5881

            // Set tips

5882

1

            assert_ok!(ServicesPayment::set_max_tip(

5883

1

                root_origin(),

5884

1

                para_id_1003.into(),

5885

1

                Some(max_tip_1003),

5886

));

5887

1

            assert_ok!(ServicesPayment::set_max_tip(

5888

1

                root_origin(),

5889

1

                para_id_1002.into(),

5890

1

                Some(max_tip_1002),

5891

));

5892

5893

1

            run_to_session(2);

5894

5895

1

            assert_eq!(

5896

1

                CollatorAssignment::collator_container_chain().container_chains

5897

1

                    [&para_id_1003.into()]

5898

1

                    .len(),

5899

5900

);

5901

1

            assert_eq!(

5902

1

                CollatorAssignment::collator_container_chain().container_chains

5903

1

                    [&para_id_1002.into()]

5904

1

                    .len(),

5905

5906

);

5907

5908

            // Should have withdrawn the lowest tip from both paras

5909

1

            assert_eq!(

5910

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1003.into())),

5911

1

                tank_funds - max_tip_1002 * 2,

5912

);

5913

5914

1

            assert_eq!(

5915

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1002.into())),

5916

1

                tank_funds - max_tip_1002 * 2,

5917

);

5918

1

});

5919

1

5920

5921

#[test]

5922

1

fn test_migration_registrar_reserves_to_hold() {

5923

1

    ExtBuilder::default()

5924

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

5925

1

        .build()

5926

1

        .execute_with(|| {

5927

            use {

5928

                frame_support::traits::{fungible::InspectHold, ReservableCurrency},

5929

                pallet_registrar::DepositInfo,

5930

                tanssi_runtime_common::migrations::RegistrarReserveToHoldMigration,

5931

};

5932

5933

1

            let deposit: Balance = 100 * UNIT;

5934

1

            let account: AccountId = DAVE.into();

5935

5936

1

            assert_ok!(Balances::reserve(&account, deposit));

5937

5938

1

            pallet_registrar::RegistrarDeposit::<Runtime>::insert(

5939

1

                ParaId::from(1001),

5940

1

                DepositInfo {

5941

1

                    creator: account.clone(),

5942

1

                    deposit,

5943

1

},

5944

);

5945

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

5946

            // Apply migration

5947

1

            let migration = RegistrarReserveToHoldMigration::<Runtime>(Default::default());

5948

1

            migration.migrate(Default::default());

5949

5950

            // Holds also count as reserved balance, so the total reserved amount

5951

            // shouldn't change after the migration

5952

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

5953

5954

1

            assert_eq!(

5955

1

                Balances::balance_on_hold(

5956

1

                    &pallet_registrar::HoldReason::RegistrarDeposit.into(),

5957

1

                    &account

5958

),

5959

                deposit

5960

);

5961

1

})

5962

1

5963

5964

#[test]

5965

1

fn test_migration_stream_payment_config_new_fields() {

5966

1

    ExtBuilder::default().build().execute_with(|| {

5967

        use pallet_stream_payment::{

5968

            migrations::{OldChangeRequest, OldStream, OldStreamConfig},

5969

            ChangeKind, ChangeRequest, DepositChange, Party, Stream, StreamConfig,

5970

};

5971

        use tanssi_runtime_common::migrations::MigrateStreamPaymentNewConfigFields;

5972

5973

1

        frame_support::storage::unhashed::put(

5974

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(0),

5975

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

5976

1

                source: ALICE.into(),

5977

1

                target: BOB.into(),

5978

1

                config: OldStreamConfig {

5979

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

5980

1

                    asset_id: StreamPaymentAssetId::Native,

5981

1

                    rate: 41,

5982

1

},

5983

1

                deposit: 42,

5984

1

                last_time_updated: 43,

5985

1

                request_nonce: 44,

5986

1

                pending_request: Some(OldChangeRequest {

5987

1

                    requester: Party::Source,

5988

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

5989

1

                    new_config: OldStreamConfig {

5990

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

5991

1

                        asset_id: StreamPaymentAssetId::Native,

5992

1

                        rate: 46,

5993

1

},

5994

1

                    deposit_change: Some(DepositChange::Absolute(47)),

5995

1

}),

5996

1

                opening_deposit: 48,

5997

1

},

5998

);

5999

6000

1

        frame_support::storage::unhashed::put(

6001

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(1),

6002

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

6003

1

                source: CHARLIE.into(),

6004

1

                target: ALICE.into(),

6005

1

                config: OldStreamConfig {

6006

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

6007

1

                    asset_id: StreamPaymentAssetId::Native,

6008

1

                    rate: 100,

6009

1

},

6010

1

                deposit: 101,

6011

1

                last_time_updated: 102,

6012

1

                request_nonce: 103,

6013

1

                pending_request: None,

6014

1

                opening_deposit: 104,

6015

1

},

6016

);

6017

6018

1

        let migration = MigrateStreamPaymentNewConfigFields::<Runtime>(Default::default());

6019

1

        migration.migrate(Default::default());

6020

6021

1

        assert_eq!(

6022

1

            pallet_stream_payment::Streams::<Runtime>::get(0).unwrap(),

6023

1

            Stream {

6024

1

                source: ALICE.into(),

6025

1

                target: BOB.into(),

6026

1

                config: StreamConfig {

6027

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

6028

1

                    asset_id: StreamPaymentAssetId::Native,

6029

1

                    rate: 41,

6030

1

                    minimum_request_deadline_delay: 0,

6031

1

                    soft_minimum_deposit: 0,

6032

1

},

6033

1

                deposit: 42,

6034

1

                last_time_updated: 43,

6035

1

                request_nonce: 44,

6036

1

                pending_request: Some(ChangeRequest {

6037

1

                    requester: Party::Source,

6038

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

6039

1

                    new_config: StreamConfig {

6040

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

6041

1

                        asset_id: StreamPaymentAssetId::Native,

6042

1

                        rate: 46,

6043

1

                        minimum_request_deadline_delay: 0,

6044

1

                        soft_minimum_deposit: 0,

6045

1

},

6046

1

                    deposit_change: Some(DepositChange::Absolute(47)),

6047

1

}),

6048

1

                opening_deposit: 48,

6049

1

6050

);

6051

6052

1

        assert_eq!(

6053

1

            pallet_stream_payment::Streams::<Runtime>::get(1).unwrap(),

6054

1

            Stream {

6055

1

                source: CHARLIE.into(),

6056

1

                target: ALICE.into(),

6057

1

                config: StreamConfig {

6058

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

6059

1

                    asset_id: StreamPaymentAssetId::Native,

6060

1

                    rate: 100,

6061

1

                    minimum_request_deadline_delay: 0,

6062

1

                    soft_minimum_deposit: 0,

6063

1

},

6064

1

                deposit: 101,

6065

1

                last_time_updated: 102,

6066

1

                request_nonce: 103,

6067

1

                pending_request: None,

6068

1

                opening_deposit: 104,

6069

1

6070

);

6071

1

})

6072

1

6073

6074

#[test]

6075

1

fn test_migration_pooled_staking_summaries() {

6076

1

    ExtBuilder::default()

6077

1

        .with_balances(vec![

6078

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6079

1

            (AccountId::from(BOB), 100_000 * UNIT),

6080

1

])

6081

1

        .build()

6082

1

        .execute_with(|| {

6083

            use pallet_pooled_staking::{

6084

                CandidateSummaries, CandidateSummary, DelegatorCandidateSummaries,

6085

                DelegatorCandidateSummary, Pools, PoolsKey,

6086

};

6087

6088

            // We'll write directly shares to storage, then run the migrations and

6089

            // checks the summaries matches.

6090

6091

1

            let alice = AccountId::from(ALICE);

6092

1

            let bob = AccountId::from(BOB);

6093

1

            let charlie = AccountId::from(CHARLIE);

6094

6095

1

            Pools::<Runtime>::insert(

6096

1

                alice.clone(),

6097

1

                PoolsKey::JoiningShares {

6098

1

                    delegator: alice.clone(),

6099

1

},

6100

42,

6101

);

6102

1

            Pools::<Runtime>::insert(

6103

1

                alice.clone(),

6104

1

                PoolsKey::AutoCompoundingShares {

6105

1

                    delegator: bob.clone(),

6106

1

},

6107

42,

6108

);

6109

6110

1

            Pools::<Runtime>::insert(

6111

1

                bob.clone(),

6112

1

                PoolsKey::ManualRewardsShares {

6113

1

                    delegator: alice.clone(),

6114

1

},

6115

42,

6116

);

6117

6118

            // let's test 0 value is ignored

6119

1

            Pools::<Runtime>::insert(

6120

1

                bob.clone(),

6121

1

                PoolsKey::ManualRewardsShares {

6122

1

                    delegator: charlie.clone(),

6123

1

},

6124

0,

6125

);

6126

6127

            // Run migration

6128

1

            StorageVersion::new(0u16).put::<PooledStaking>(); // set version required for migration to run

6129

1

            pallet_pooled_staking::migrations::MigrationGenerateSummaries::<Runtime>::step(

6130

1

                None,

6131

1

                &mut WeightMeter::new(),

6132

6133

1

            .expect("to run without errors");

6134

6135

            // Check output

6136

1

            assert_eq!(CandidateSummaries::<Runtime>::iter().count(), 2);

6137

1

            assert_eq!(

6138

1

                CandidateSummaries::<Runtime>::get(&alice),

6139

1

                CandidateSummary {

6140

1

                    delegators: 2,

6141

1

                    joining_delegators: 1,

6142

1

                    auto_compounding_delegators: 1,

6143

1

                    ..Default::default()

6144

1

6145

);

6146

1

            assert_eq!(

6147

1

                CandidateSummaries::<Runtime>::get(&bob),

6148

1

                CandidateSummary {

6149

1

                    delegators: 1,

6150

1

                    manual_rewards_delegators: 1,

6151

1

                    ..Default::default()

6152

1

6153

);

6154

6155

1

            assert_eq!(DelegatorCandidateSummaries::<Runtime>::iter().count(), 3);

6156

1

            assert_eq!(

6157

1

                DelegatorCandidateSummaries::<Runtime>::get(&alice, &alice),

6158

1

                DelegatorCandidateSummary::default().with_joining(true)

6159

);

6160

1

            assert_eq!(

6161

1

                DelegatorCandidateSummaries::<Runtime>::get(&alice, &bob),

6162

1

                DelegatorCandidateSummary::default().with_manual(true)

6163

);

6164

1

            assert_eq!(

6165

1

                DelegatorCandidateSummaries::<Runtime>::get(&bob, &alice),

6166

1

                DelegatorCandidateSummary::default().with_auto(true)

6167

);

6168

1

});

6169

1

6170

6171

#[test]

6172

1

fn test_container_deregister_unassign_data_preserver() {

6173

1

    ExtBuilder::default()

6174

1

        .with_balances(vec![

6175

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6176

1

            (AccountId::from(BOB), 100_000 * UNIT),

6177

1

])

6178

1

        .build()

6179

1

        .execute_with(|| {

6180

            use pallet_data_preservers::{

6181

                AssignerParameterOf, NodeType, ParaIdsFilter, Profile, ProviderRequestOf,

6182

};

6183

6184

1

            let profile = Profile {

6185

1

                bootnode_url: Some(b"test".to_vec().try_into().unwrap()),

6186

1

                direct_rpc_urls: Default::default(),

6187

1

                proxy_rpc_urls: Default::default(),

6188

1

                para_ids: ParaIdsFilter::AnyParaId,

6189

1

                node_type: NodeType::Substrate,

6190

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

6191

1

                additional_info: Default::default(),

6192

1

};

6193

6194

1

            let para_id = ParaId::from(1002);

6195

1

            let profile_id = 0u64;

6196

6197

1

            assert_ok!(Registrar::register(

6198

1

                origin_of(ALICE.into()),

6199

1

                para_id,

6200

1

                empty_genesis_data(),

6201

1

                None

6202

));

6203

6204

1

            assert_ok!(DataPreservers::create_profile(

6205

1

                origin_of(BOB.into()),

6206

1

                profile.clone(),

6207

));

6208

6209

            // Start assignment

6210

1

            assert_ok!(DataPreservers::start_assignment(

6211

1

                origin_of(ALICE.into()),

6212

1

                profile_id,

6213

1

                para_id,

6214

1

                AssignerParameterOf::<Runtime>::Free

6215

));

6216

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&0u64));

6217

6218

            // Deregister from Registrar

6219

1

            assert_ok!(Registrar::deregister(root_origin(), para_id), ());

6220

6221

            // Check DataPreserver assignment has been cleared

6222

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).is_empty());

6223

1

});

6224

1

6225

6226

#[test]

6227

1

fn test_data_preserver_with_stream_payment() {

6228

1

    ExtBuilder::default()

6229

1

        .with_balances(vec![

6230

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6231

1

            (AccountId::from(BOB), 100_000 * UNIT),

6232

1

])

6233

1

        .build()

6234

1

        .execute_with(|| {

6235

            use pallet_data_preservers::{

6236

                AssignerParameterOf, NodeType, ParaIdsFilter, Profile, ProviderRequestOf,

6237

};

6238

6239

1

            let profile = Profile {

6240

1

                bootnode_url: Some(b"test".to_vec().try_into().unwrap()),

6241

1

                direct_rpc_urls: Default::default(),

6242

1

                proxy_rpc_urls: Default::default(),

6243

1

                para_ids: ParaIdsFilter::AnyParaId,

6244

1

                node_type: NodeType::Substrate,

6245

1

                additional_info: Default::default(),

6246

1

                assignment_request: ProviderRequestOf::<Runtime>::StreamPayment {

6247

1

                    config: StreamConfig {

6248

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

6249

1

                        asset_id: StreamPaymentAssetId::Native,

6250

1

                        rate: 42,

6251

1

                        minimum_request_deadline_delay: 0,

6252

1

                        soft_minimum_deposit: 0,

6253

1

},

6254

1

},

6255

1

};

6256

6257

1

            let para_id = ParaId::from(1002);

6258

1

            let profile_id = 0u64;

6259

6260

1

            assert_ok!(Registrar::register(

6261

1

                origin_of(ALICE.into()),

6262

1

                para_id,

6263

1

                empty_genesis_data(),

6264

1

                None

6265

));

6266

6267

1

            assert_ok!(DataPreservers::create_profile(

6268

1

                origin_of(BOB.into()),

6269

1

                profile.clone(),

6270

));

6271

6272

            // Start assignment

6273

1

            assert_ok!(DataPreservers::start_assignment(

6274

1

                origin_of(ALICE.into()),

6275

1

                profile_id,

6276

1

                para_id,

6277

1

                AssignerParameterOf::<Runtime>::StreamPayment {

6278

1

                    initial_deposit: 1_000

6279

1

6280

));

6281

1

            assert!(

6282

1

                pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&profile_id)

6283

);

6284

1

            let profile = pallet_data_preservers::Profiles::<Runtime>::get(profile_id)

6285

1

                .expect("profile to exists");

6286

1

            let (assigned_para_id, witness) = profile.assignment.expect("profile to be assigned");

6287

1

            assert_eq!(assigned_para_id, para_id);

6288

1

            assert_eq!(

6289

                witness,

6290

                tp_data_preservers_common::AssignmentWitness::StreamPayment { stream_id: 0 }

6291

);

6292

1

});

6293

1

6294

6295

#[test]

6296

1

fn test_data_preserver_kind_needs_to_match() {

6297

1

    ExtBuilder::default()

6298

1

        .with_balances(vec![

6299

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6300

1

            (AccountId::from(BOB), 100_000 * UNIT),

6301

1

])

6302

1

        .build()

6303

1

        .execute_with(|| {

6304

            use pallet_data_preservers::{

6305

                AssignerParameterOf, NodeType, ParaIdsFilter, Profile, ProviderRequestOf,

6306

};

6307

6308

1

            let profile = Profile {

6309

1

                bootnode_url: Some(b"test".to_vec().try_into().unwrap()),

6310

1

                direct_rpc_urls: Default::default(),

6311

1

                proxy_rpc_urls: Default::default(),

6312

1

                para_ids: ParaIdsFilter::AnyParaId,

6313

1

                node_type: NodeType::Substrate,

6314

1

                additional_info: Default::default(),

6315

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

6316

1

};

6317

6318

1

            let para_id = ParaId::from(1002);

6319

1

            let profile_id = 0u64;

6320

6321

1

            assert_ok!(Registrar::register(

6322

1

                origin_of(ALICE.into()),

6323

1

                para_id,

6324

1

                empty_genesis_data(),

6325

1

                None

6326

));

6327

6328

1

            assert_ok!(DataPreservers::create_profile(

6329

1

                origin_of(BOB.into()),

6330

1

                profile.clone(),

6331

));

6332

6333

            // Start assignment

6334

1

            assert_err!(

6335

1

                DataPreservers::start_assignment(

6336

1

                    origin_of(ALICE.into()),

6337

1

                    profile_id,

6338

1

                    para_id,

6339

1

                    AssignerParameterOf::<Runtime>::StreamPayment {

6340

1

                        initial_deposit: 1_000

6341

1

6342

),

6343

1

                pallet_data_preservers::Error::<Runtime>::AssignmentPaymentRequestParameterMismatch

6344

);

6345

1

});

6346

1

6347

6348

#[test]

6349

1

fn test_registrar_extrinsic_permissions() {

6350

1

    ExtBuilder::default()

6351

1

        .with_balances(vec![

6352

1

6353

1

                cumulus_primitives_core::relay_chain::AccountId::from(ALICE),

6354

1

                210_000 * UNIT,

6355

1

),

6356

1

6357

1

                cumulus_primitives_core::relay_chain::AccountId::from(BOB),

6358

1

                100_000 * UNIT,

6359

1

),

6360

1

])

6361

1

        .with_empty_parachains(vec![1001])

6362

1

        .build()

6363

1

        .execute_with(|| {

6364

1

            let para_id = ParaId::from(1001);

6365

6366

            // Pause container chain should fail if not para manager

6367

1

            assert_noop!(

6368

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

6369

1

                BadOrigin

6370

);

6371

6372

            // Set Bob as para manager

6373

1

            assert_ok!(Registrar::set_para_manager(

6374

1

                root_origin(),

6375

1

                para_id,

6376

1

                AccountId::from(BOB)

6377

));

6378

6379

            // Pause container chain should succeed if para manager

6380

1

            assert_ok!(

6381

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

6382

()

6383

);

6384

1

});

6385

1