Grcov report - integration

1

// Copyright (C) Moondance Labs Ltd.

2

// This file is part of Tanssi.

3

4

// Tanssi is free software: you can redistribute it and/or modify

5

// it under the terms of the GNU General Public License as published by

6

// the Free Software Foundation, either version 3 of the License, or

7

// (at your option) any later version.

8

9

// Tanssi is distributed in the hope that it will be useful,

10

// but WITHOUT ANY WARRANTY; without even the implied warranty of

11

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

12

// GNU General Public License for more details.

13

14

// You should have received a copy of the GNU General Public License

15

// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>

16

17

#![cfg(test)]

18

19

use {

20

    crate::{tests::common::*, RewardsCollatorCommission, StreamPayment, TransactionPayment},

21

    cumulus_primitives_core::ParaId,

22

    dp_consensus::runtime_decl_for_tanssi_authority_assignment_api::TanssiAuthorityAssignmentApiV1,

23

    dp_core::well_known_keys,

24

    frame_support::{

25

        assert_err, assert_noop, assert_ok, migrations::SteppedMigration,

26

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

27

},

28

    frame_system::ConsumedWeight,

29

    nimbus_primitives::NIMBUS_KEY_ID,

30

    pallet_author_noting_runtime_api::runtime_decl_for_author_noting_api::AuthorNotingApi,

31

    pallet_balances::Instance1,

32

    pallet_collator_assignment_runtime_api::runtime_decl_for_collator_assignment_api::CollatorAssignmentApi,

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

    sp_std::vec,

51

    tanssi_runtime_common::migrations::{

52

        HostConfigurationV3, MigrateConfigurationAddFullRotationMode,

53

        MigrateServicesPaymentAddCollatorAssignmentCredits, RegistrarPendingVerificationValueToMap,

54

},

55

    test_relay_sproof_builder::{HeaderAs, ParaHeaderSproofBuilder, ParaHeaderSproofBuilderItem},

56

    tp_stream_payment_common::{

57

        AssetId as StreamPaymentAssetId, TimeUnit as StreamPaymentTimeUnit,

58

},

59

    tp_traits::{ContainerChainBlockInfo, SlotFrequency},

60

    xcm::latest::prelude::*,

61

};

62

63

#[test]

64

1

fn genesis_balances() {

65

1

    ExtBuilder::default()

66

1

        .with_balances(vec![

67

1

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

68

1

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

69

1

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

70

1

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

71

1

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

72

1

])

73

1

        .with_collators(vec![

74

1

            // Remove ALICE and BOB from collators

75

1

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

76

1

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

77

1

])

78

1

        .build()

79

1

        .execute_with(|| {

80

1

            assert_eq!(

81

1

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

82

1

                210_000 * UNIT,

83

1

);

84

1

            assert_eq!(

85

1

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

86

1

                100_000 * UNIT,

87

1

);

88

1

});

89

1

90

91

#[test]

92

1

fn genesis_para_registrar() {

93

1

    ExtBuilder::default()

94

1

        .with_empty_parachains(vec![1001, 1002])

95

1

        .build()

96

1

        .execute_with(|| {

97

1

            assert_eq!(

98

1

                Registrar::registered_para_ids(),

99

1

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

100

1

);

101

1

});

102

1

103

104

#[test]

105

1

fn genesis_para_registrar_deregister() {

106

1

    ExtBuilder::default()

107

1

        .with_empty_parachains(vec![1001, 1002])

108

1

        .build()

109

1

        .execute_with(|| {

110

1

            assert_eq!(

111

1

                Registrar::registered_para_ids(),

112

1

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

113

1

);

114

115

1

            run_to_block(2);

116

1

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

117

118

            // Pending

119

1

            assert_eq!(

120

1

                Registrar::pending_registered_para_ids(),

121

1

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

122

1

);

123

124

1

            run_to_session(1);

125

1

            assert_eq!(

126

1

                Registrar::pending_registered_para_ids(),

127

1

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

128

1

);

129

1

            assert_eq!(

130

1

                Registrar::registered_para_ids(),

131

1

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

132

1

);

133

134

1

            run_to_session(2);

135

1

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

136

1

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

137

1

});

138

1

139

140

#[test]

141

1

fn genesis_para_registrar_runtime_api() {

142

1

    ExtBuilder::default()

143

1

        .with_empty_parachains(vec![1001, 1002])

144

1

        .build()

145

1

        .execute_with(|| {

146

1

            assert_eq!(

147

1

                Registrar::registered_para_ids(),

148

1

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

149

1

);

150

1

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

151

152

1

            run_to_block(2);

153

1

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

154

1

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

155

156

1

            run_to_session(1);

157

1

            assert_eq!(

158

1

                Registrar::registered_para_ids(),

159

1

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

160

1

);

161

1

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

162

163

1

            run_to_session(2);

164

1

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

165

1

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

166

1

});

167

1

168

169

#[test]

170

1

fn genesis_para_registrar_container_chain_genesis_data_runtime_api() {

171

1

    let genesis_data_1001 = empty_genesis_data();

172

1

    let genesis_data_1002 = ContainerChainGenesisData {

173

1

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

174

1

        name: Default::default(),

175

1

        id: Default::default(),

176

1

        fork_id: Default::default(),

177

1

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

178

1

        properties: Default::default(),

179

1

};

180

1

    ExtBuilder::default()

181

1

        .with_para_ids(vec![

182

1

            ParaRegistrationParams {

183

1

                para_id: 1001,

184

1

                genesis_data: genesis_data_1001.clone(),

185

1

                block_production_credits: u32::MAX,

186

1

                collator_assignment_credits: u32::MAX,

187

1

                parathread_params: None,

188

1

            },ParaRegistrationParams {

189

1

                para_id: 1002,

190

1

                genesis_data: genesis_data_1002.clone(),

191

1

                block_production_credits: u32::MAX,

192

1

                collator_assignment_credits: u32::MAX,

193

1

                parathread_params: None,

194

1

},

195

1

])

196

1

        .build()

197

1

        .execute_with(|| {

198

1

            assert_eq!(

199

1

                Registrar::registered_para_ids(),

200

1

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

201

1

);

202

1

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

203

204

1

            assert_eq!(

205

1

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

206

1

                Some(&genesis_data_1001)

207

1

);

208

1

            assert_eq!(

209

1

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

210

1

                Some(&genesis_data_1002)

211

1

);

212

1

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

213

214

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

215

            // with id 100

216

            // TODO: where is that 100 defined?

217

1

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

218

219

1

            run_to_block(2);

220

1

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

221

222

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

223

224

1

            let genesis_data_1003 = ContainerChainGenesisData {

225

1

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

226

1

                name: Default::default(),

227

1

                id: Default::default(),

228

1

                fork_id: Default::default(),

229

1

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

230

1

                properties: Default::default(),

231

1

};

232

1

            assert_ok!(

233

1

                Registrar::register(

234

1

                    origin_of(ALICE.into()),

235

1

                    1003.into(),

236

1

                    genesis_data_1003.clone(),

237

1

                    None

238

1

),

239

1

()

240

1

);

241

242

            // Registered container chains are inserted immediately

243

1

            assert_eq!(

244

1

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

245

1

                Some(&genesis_data_1003)

246

1

);

247

248

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

249

1

            run_to_session(2u32);

250

1

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

251

1

});

252

1

253

254

#[test]

255

1

fn test_author_collation_aura() {

256

1

    ExtBuilder::default()

257

1

        .with_empty_parachains(vec![1001, 1002])

258

1

        .build()

259

1

        .execute_with(|| {

260

1

            run_to_block(5);

261

1

            // Assert current slot gets updated

262

1

            assert_eq!(current_slot(), 4u64);

263

            // slot 4, alice

264

1

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

265

266

1

            run_to_block(6);

267

1

268

1

            assert_eq!(current_slot(), 5u64);

269

            // slot 5, bob

270

1

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

271

1

});

272

1

273

274

#[test]

275

1

fn test_author_collation_aura_change_of_authorities_on_session() {

276

1

    ExtBuilder::default()

277

1

        .with_balances(vec![

278

1

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

279

1

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

280

1

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

281

1

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

282

1

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

283

1

])

284

1

        .with_empty_parachains(vec![1001, 1002])

285

1

        .build()

286

1

        .execute_with(|| {

287

1

            run_to_block(2);

288

1

            // Assert current slot gets updated

289

1

            assert_eq!(current_slot(), 1u64);

290

1

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

291

292

            // We change invulnerables

293

            // We first need to set the keys

294

1

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

295

1

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

296

1

297

1

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

298

1

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

299

1

300

1

            // Set CHARLIE and DAVE keys

301

1

            assert_ok!(Session::set_keys(

302

1

                origin_of(CHARLIE.into()),

303

1

                crate::SessionKeys {

304

1

                    nimbus: charlie_id.clone(),

305

1

},

306

1

                vec![]

307

1

));

308

1

            assert_ok!(Session::set_keys(

309

1

                origin_of(DAVE.into()),

310

1

                crate::SessionKeys {

311

1

                    nimbus: dave_id.clone(),

312

1

},

313

1

                vec![]

314

1

));

315

316

            // Change invulnerables

317

1

            assert_ok!(Invulnerables::remove_invulnerable(

318

1

                root_origin(),

319

1

                ALICE.into()

320

1

));

321

1

            assert_ok!(Invulnerables::remove_invulnerable(

322

1

                root_origin(),

323

1

                BOB.into()

324

1

));

325

1

            assert_ok!(Invulnerables::add_invulnerable(

326

1

                root_origin(),

327

1

                CHARLIE.into()

328

1

));

329

1

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

330

331

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

332

1

            run_to_session(1u32);

333

1

            let author = get_orchestrator_current_author().unwrap();

334

1

335

1

            assert_eq!(current_author(), author);

336

1

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

337

338

            // Invulnerables should have triggered on new session authorities change

339

1

            run_to_session(2u32);

340

1

            let author_after_changes = get_orchestrator_current_author().unwrap();

341

1

342

1

            assert_eq!(current_author(), author_after_changes);

343

1

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

344

1

});

345

1

346

347

#[test]

348

1

fn test_author_collation_aura_add_assigned_to_paras() {

349

1

    ExtBuilder::default()

350

1

        .with_balances(vec![

351

1

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

352

1

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

353

1

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

354

1

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

355

1

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

356

1

])

357

1

        .with_empty_parachains(vec![1001, 1002])

358

1

        .build()

359

1

        .execute_with(|| {

360

1

            run_to_block(2);

361

1

            // Assert current slot gets updated

362

1

            assert_eq!(current_slot(), 1u64);

363

1

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

364

365

            // We change invulnerables

366

            // We first need to set the keys

367

1

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

368

1

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

369

1

370

1

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

371

1

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

372

1

373

1

            // Set CHARLIE and DAVE keys

374

1

            assert_ok!(Session::set_keys(

375

1

                origin_of(CHARLIE.into()),

376

1

                crate::SessionKeys { nimbus: charlie_id },

377

1

                vec![]

378

1

));

379

1

            assert_ok!(Session::set_keys(

380

1

                origin_of(DAVE.into()),

381

1

                crate::SessionKeys { nimbus: dave_id },

382

1

                vec![]

383

1

));

384

385

            // Add new invulnerables

386

1

            assert_ok!(Invulnerables::add_invulnerable(

387

1

                root_origin(),

388

1

                CHARLIE.into()

389

1

));

390

1

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

391

392

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

393

1

            run_to_session(1u32);

394

1

            let author = get_orchestrator_current_author().unwrap();

395

1

396

1

            assert_eq!(current_author(), author);

397

1

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

398

399

            // Invulnerables should have triggered on new session authorities change

400

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

401

1

            run_to_session(2u32);

402

1

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

403

1

            let assignment = CollatorAssignment::collator_container_chain();

404

1

            assert_eq!(

405

1

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

406

1

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

407

1

);

408

1

});

409

1

410

411

#[test]

412

1

fn test_authors_without_paras() {

413

1

    ExtBuilder::default()

414

1

        .with_balances(vec![

415

1

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

416

1

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

417

1

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

418

1

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

419

1

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

420

1

])

421

1

        .with_collators(vec![

422

1

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

423

1

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

424

1

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

425

1

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

426

1

])

427

1

        .build()

428

1

        .execute_with(|| {

429

1

            run_to_block(2);

430

1

            // Assert current slot gets updated

431

1

            assert_eq!(current_slot(), 1u64);

432

1

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

433

434

            // Only Alice and Bob collate for our chain

435

1

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

436

1

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

437

1

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

438

1

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

439

1

440

1

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

441

1

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

442

443

            // Set moondance collators to min 2 max 5

444

1

            assert_ok!(

445

1

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

446

1

()

447

1

);

448

1

            assert_ok!(

449

1

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

450

1

()

451

1

);

452

453

1

            run_to_session(2);

454

1

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

455

1

});

456

1

457

458

#[test]

459

1

fn test_authors_paras_inserted_a_posteriori() {

460

1

    ExtBuilder::default()

461

1

        .with_balances(vec![

462

1

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

463

1

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

464

1

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

465

1

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

466

1

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

467

1

])

468

1

        .with_collators(vec![

469

1

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

470

1

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

471

1

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

472

1

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

473

1

])

474

1

        .build()

475

1

        .execute_with(|| {

476

1

            run_to_block(2);

477

1

            // Assert current slot gets updated

478

1

            assert_eq!(current_slot(), 1u64);

479

1

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

480

481

            // Alice and Bob collate in our chain

482

1

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

483

1

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

484

1

485

1

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

486

487

1

            assert_ok!(Registrar::register(

488

1

                origin_of(ALICE.into()),

489

1

                1001.into(),

490

1

                empty_genesis_data(),

491

1

                None

492

1

));

493

1

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

494

1

            assert_ok!(Registrar::mark_valid_for_collating(

495

1

                root_origin(),

496

1

                1001.into()

497

1

));

498

1

            assert_ok!(ServicesPayment::purchase_credits(

499

1

                origin_of(ALICE.into()),

500

1

                1001.into(),

501

1

                block_credits_to_required_balance(1000, 1001.into())

502

1

));

503

1

            assert_ok!(Registrar::register(

504

1

                origin_of(ALICE.into()),

505

1

                1002.into(),

506

1

                empty_genesis_data(),

507

1

                None

508

1

));

509

1

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

510

1

            assert_ok!(Registrar::mark_valid_for_collating(

511

1

                root_origin(),

512

1

                1002.into()

513

1

));

514

1

            assert_ok!(ServicesPayment::purchase_credits(

515

1

                origin_of(ALICE.into()),

516

1

                1002.into(),

517

1

                block_credits_to_required_balance(1000, 1002.into())

518

1

));

519

520

            // Assignment should happen after 2 sessions

521

1

            run_to_session(1u32);

522

1

            let assignment = CollatorAssignment::collator_container_chain();

523

1

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

524

1

            run_to_session(2u32);

525

1

526

1

            // Charlie and Dave should be assigned to para 1001

527

1

            let assignment = CollatorAssignment::collator_container_chain();

528

1

            assert_eq!(

529

1

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

530

1

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

531

1

);

532

1

});

533

1

534

535

#[test]

536

1

fn test_authors_paras_inserted_a_posteriori_with_collators_already_assigned() {

537

1

    ExtBuilder::default()

538

1

        .with_balances(vec![

539

1

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

540

1

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

541

1

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

542

1

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

543

1

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

544

1

])

545

1

        .with_collators(vec![

546

1

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

547

1

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

548

1

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

549

1

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

550

1

])

551

1

        .with_config(pallet_configuration::HostConfiguration {

552

1

            max_collators: 100,

553

1

            min_orchestrator_collators: 2,

554

1

            max_orchestrator_collators: 5,

555

1

            collators_per_container: 2,

556

1

            full_rotation_period: 24,

557

1

            ..Default::default()

558

1

})

559

1

        .build()

560

1

        .execute_with(|| {

561

1

            run_to_block(2);

562

1

            // Assert current slot gets updated

563

1

            assert_eq!(current_slot(), 1u64);

564

1

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

565

566

            // Alice and Bob collate in our chain

567

1

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

568

1

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

569

1

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

570

1

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

571

1

572

1

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

573

574

1

            assert_ok!(Registrar::register(

575

1

                origin_of(ALICE.into()),

576

1

                1001.into(),

577

1

                empty_genesis_data(),

578

1

                None

579

1

));

580

1

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

581

1

            assert_ok!(Registrar::mark_valid_for_collating(

582

1

                root_origin(),

583

1

                1001.into()

584

1

));

585

1

            assert_ok!(ServicesPayment::purchase_credits(

586

1

                origin_of(ALICE.into()),

587

1

                1001.into(),

588

1

                block_credits_to_required_balance(1000, 1001.into())

589

1

));

590

591

            // Assignment should happen after 2 sessions

592

1

            run_to_session(1u32);

593

1

            let assignment = CollatorAssignment::collator_container_chain();

594

1

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

595

1

            run_to_session(2u32);

596

1

597

1

            // Charlie and Dave are now assigned to para 1001

598

1

            let assignment = CollatorAssignment::collator_container_chain();

599

1

            assert_eq!(

600

1

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

601

1

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

602

1

);

603

1

            assert_eq!(

604

1

                assignment.orchestrator_chain,

605

1

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

606

1

);

607

1

});

608

1

609

610

#[test]

611

1

fn test_paras_registered_but_zero_credits() {

612

1

    ExtBuilder::default()

613

1

        .with_balances(vec![

614

1

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

615

1

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

616

1

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

617

1

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

618

1

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

619

1

])

620

1

        .with_collators(vec![

621

1

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

622

1

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

623

1

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

624

1

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

625

1

])

626

1

        .build()

627

1

        .execute_with(|| {

628

1

            run_to_block(2);

629

1

            // Assert current slot gets updated

630

1

            assert_eq!(current_slot(), 1u64);

631

1

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

632

633

            // Alice and Bob collate in our chain

634

1

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

635

1

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

636

1

637

1

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

638

639

1

            assert_ok!(Registrar::register(

640

1

                origin_of(ALICE.into()),

641

1

                1001.into(),

642

1

                empty_genesis_data(),

643

1

                None

644

1

));

645

1

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

646

1

            assert_ok!(Registrar::mark_valid_for_collating(

647

1

                root_origin(),

648

1

                1001.into()

649

1

));

650

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

651

1

            assert_ok!(ServicesPayment::set_block_production_credits(

652

1

                root_origin(),

653

1

                1001.into(),

654

1

655

1

));

656

657

            // Assignment should happen after 2 sessions

658

1

            run_to_session(1u32);

659

1

            let assignment = CollatorAssignment::collator_container_chain();

660

1

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

661

1

            run_to_session(2u32);

662

1

663

1

            // Nobody should be assigned to para 1001

664

1

            let assignment = CollatorAssignment::collator_container_chain();

665

1

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

666

1

});

667

1

668

669

#[test]

670

1

fn test_paras_registered_but_not_enough_credits() {

671

1

    ExtBuilder::default()

672

1

        .with_balances(vec![

673

1

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

674

1

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

675

1

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

676

1

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

677

1

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

678

1

])

679

1

        .with_collators(vec![

680

1

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

681

1

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

682

1

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

683

1

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

684

1

])

685

1

        .build()

686

1

        .execute_with(|| {

687

1

            run_to_block(2);

688

1

            // Assert current slot gets updated

689

1

            assert_eq!(current_slot(), 1u64);

690

1

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

691

692

            // Alice and Bob collate in our chain

693

1

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

694

1

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

695

1

696

1

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

697

698

1

            assert_ok!(Registrar::register(

699

1

                origin_of(ALICE.into()),

700

1

                1001.into(),

701

1

                empty_genesis_data(),

702

1

                None

703

1

));

704

1

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

705

1

            assert_ok!(Registrar::mark_valid_for_collating(

706

1

                root_origin(),

707

1

                1001.into()

708

1

));

709

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

710

1

            assert_ok!(ServicesPayment::set_block_production_credits(

711

1

                root_origin(),

712

1

                1001.into(),

713

1

714

1

));

715

            // Purchase 1 credit less that what is needed

716

1

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

717

1

            assert_ok!(ServicesPayment::set_block_production_credits(

718

1

                root_origin(),

719

1

                1001.into(),

720

1

                credits_1001

721

1

));

722

723

            // Assignment should happen after 2 sessions

724

1

            run_to_session(1u32);

725

1

            let assignment = CollatorAssignment::collator_container_chain();

726

1

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

727

1

            run_to_session(2u32);

728

1

            // Nobody should be assigned to para 1001

729

1

            let assignment = CollatorAssignment::collator_container_chain();

730

1

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

731

732

            // Now purchase the missing block credit

733

1

            assert_ok!(ServicesPayment::set_block_production_credits(

734

1

                root_origin(),

735

1

                1001.into(),

736

1

                credits_1001 + 1

737

1

));

738

739

1

            run_to_session(4u32);

740

1

            // Charlie and Dave should be assigned to para 1001

741

1

            let assignment = CollatorAssignment::collator_container_chain();

742

1

            assert_eq!(

743

1

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

744

1

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

745

1

);

746

1

});

747

1

748

749

#[test]

750

1

fn test_paras_registered_but_only_credits_for_1_session() {

751

1

    ExtBuilder::default()

752

1

        .with_balances(vec![

753

1

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

754

1

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

755

1

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

756

1

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

757

1

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

758

1

])

759

1

        .with_collators(vec![

760

1

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

761

1

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

762

1

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

763

1

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

764

1

])

765

1

        .build()

766

1

        .execute_with(|| {

767

1

            run_to_block(2);

768

1

            // Assert current slot gets updated

769

1

            assert_eq!(current_slot(), 1u64);

770

1

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

771

772

            // Alice and Bob collate in our chain

773

1

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

774

1

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

775

1

776

1

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

777

778

1

            assert_ok!(Registrar::register(

779

1

                origin_of(ALICE.into()),

780

1

                1001.into(),

781

1

                empty_genesis_data(),

782

1

                None

783

1

));

784

1

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

785

1

            assert_ok!(Registrar::mark_valid_for_collating(

786

1

                root_origin(),

787

1

                1001.into()

788

1

));

789

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

790

1

            assert_ok!(ServicesPayment::set_block_production_credits(

791

1

                root_origin(),

792

1

                1001.into(),

793

1

794

1

));

795

            // Purchase only enough credits for 1 session

796

1

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

797

1

            assert_ok!(ServicesPayment::set_block_production_credits(

798

1

                root_origin(),

799

1

                1001.into(),

800

1

                credits_1001

801

1

));

802

803

            // Assignment should happen after 2 sessions

804

1

            run_to_session(1u32);

805

1

            let assignment = CollatorAssignment::collator_container_chain();

806

1

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

807

1

            run_to_session(2u32);

808

1

            // Charlie and Dave should be assigned to para 1001

809

1

            let assignment = CollatorAssignment::collator_container_chain();

810

1

            assert_eq!(

811

1

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

812

1

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

813

1

);

814

815

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

816

1

            run_block();

817

1

            let credits =

818

1

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

819

1

                    .unwrap_or_default();

820

1

            assert_eq!(credits, credits_1001);

821

822

            // Simulate block inclusion from container chain 1001

823

1

            let mut sproof = ParaHeaderSproofBuilder::default();

824

1

            let slot: u64 = 5;

825

1

            let s = ParaHeaderSproofBuilderItem {

826

1

                para_id: 1001.into(),

827

1

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

828

1

                    parent_hash: Default::default(),

829

1

                    number: 1,

830

1

                    state_root: Default::default(),

831

1

                    extrinsics_root: Default::default(),

832

1

                    digest: sp_runtime::generic::Digest {

833

1

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

834

1

},

835

1

}),

836

1

};

837

1

            sproof.items.push(s);

838

1

            set_author_noting_inherent_data(sproof);

839

1

840

1

            run_block();

841

1

            let credits =

842

1

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

843

1

                    .unwrap_or_default();

844

1

            assert_eq!(credits, credits_1001 - 1);

845

846

1

            run_to_session(4u32);

847

1

            // Nobody should be assigned to para 1001

848

1

            let assignment = CollatorAssignment::collator_container_chain();

849

1

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

850

851

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

852

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

853

1

            let credits =

854

1

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

855

1

                    .unwrap_or_default();

856

1

            assert_eq!(credits, credits_1001 - 1);

857

1

});

858

1

859

860

#[test]

861

1

fn test_parachains_deregister_collators_re_assigned() {

862

1

    ExtBuilder::default()

863

1

        .with_balances(vec![

864

1

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

865

1

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

866

1

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

867

1

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

868

1

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

869

1

])

870

1

        .with_collators(vec![

871

1

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

872

1

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

873

1

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

874

1

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

875

1

])

876

1

        .with_empty_parachains(vec![1001, 1002])

877

1

        .build()

878

1

        .execute_with(|| {

879

1

            run_to_block(2);

880

1

            // Assert current slot gets updated

881

1

            assert_eq!(current_slot(), 1u64);

882

1

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

883

884

            // Alice and Bob are authorities

885

1

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

886

1

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

887

1

888

1

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

889

890

            // Charlie and Dave to 1001

891

1

            let assignment = CollatorAssignment::collator_container_chain();

892

1

            assert_eq!(

893

1

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

894

1

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

895

1

);

896

897

1

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

898

899

            // Assignment should happen after 2 sessions

900

1

            run_to_session(1u32);

901

1

902

1

            let assignment = CollatorAssignment::collator_container_chain();

903

1

            assert_eq!(

904

1

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

905

1

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

906

1

);

907

908

1

            run_to_session(2u32);

909

1

910

1

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

911

1

            let assignment = CollatorAssignment::collator_container_chain();

912

1

            assert_eq!(

913

1

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

914

1

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

915

1

);

916

1

});

917

1

918

919

#[test]

920

1

fn test_parachains_deregister_collators_config_change_reassigned() {

921

1

    ExtBuilder::default()

922

1

        .with_balances(vec![

923

1

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

924

1

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

925

1

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

926

1

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

927

1

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

928

1

])

929

1

        .with_collators(vec![

930

1

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

931

1

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

932

1

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

933

1

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

934

1

])

935

1

        .with_empty_parachains(vec![1001, 1002])

936

1

        .build()

937

1

        .execute_with(|| {

938

1

            run_to_block(2);

939

1

            // Assert current slot gets updated

940

1

            assert_eq!(current_slot(), 1u64);

941

1

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

942

943

            // Alice and Bob are authorities

944

1

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

945

1

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

946

1

947

1

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

948

949

            // Set orchestrator collators to 1

950

1

            assert_ok!(

951

1

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

952

1

()

953

1

);

954

955

            // Set container chain collators to 3

956

1

            assert_ok!(

957

1

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

958

1

()

959

1

);

960

961

            // Charlie and Dave to 1001

962

1

            let assignment = CollatorAssignment::collator_container_chain();

963

1

            assert_eq!(

964

1

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

965

1

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

966

1

);

967

968

            // Assignment should happen after 2 sessions

969

1

            run_to_session(1u32);

970

1

971

1

            let assignment = CollatorAssignment::collator_container_chain();

972

1

            assert_eq!(

973

1

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

974

1

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

975

1

);

976

977

1

            run_to_session(2u32);

978

1

979

1

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

980

1

            let assignment = CollatorAssignment::collator_container_chain();

981

1

            assert_eq!(

982

1

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

983

1

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

984

1

);

985

986

1

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

987

1

});

988

1

989

990

#[test]

991

1

fn test_orchestrator_collators_with_non_sufficient_collators() {

992

1

    ExtBuilder::default()

993

1

        .with_balances(vec![

994

1

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

995

1

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

996

1

])

997

1

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

998

1

        .with_empty_parachains(vec![1001, 1002])

999

1

        .build()

1000

1

        .execute_with(|| {

1001

1

            run_to_block(2);

1002

1

            // Assert current slot gets updated

1003

1

            assert_eq!(current_slot(), 1u64);

1004

1

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

1005

1006

            // Alice and Bob are authorities

1007

1

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

1008

1

1009

1

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

1010

1

});

1011

1

1012

1013

#[test]

1014

1

fn test_configuration_on_session_change() {

1015

1

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

1016

1

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

1017

1

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

1018

1

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

1019

1020

1

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

1021

1

        run_to_session(1u32);

1022

1

1023

1

        assert_ok!(

1024

1

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

1025

1

()

1026

1

);

1027

1

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

1028

1

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

1029

1

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

1030

1031

1

        run_to_session(2u32);

1032

1

        assert_ok!(

1033

1

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

1034

1

()

1035

1

);

1036

1

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

1037

1

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

1038

1

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

1039

1040

1

        run_to_session(3u32);

1041

1

1042

1

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

1043

1

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

1044

1

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

1045

1046

1

        run_to_session(4u32);

1047

1

1048

1

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

1049

1

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

1050

1

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

1051

1

});

1052

1

1053

1054

#[test]

1055

1

fn test_author_collation_aura_add_assigned_to_paras_runtime_api() {

1056

1

    ExtBuilder::default()

1057

1

        .with_balances(vec![

1058

1

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

1059

1

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

1060

1

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

1061

1

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

1062

1

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

1063

1

])

1064

1

        .with_empty_parachains(vec![1001, 1002])

1065

1

        .build()

1066

1

        .execute_with(|| {

1067

1

            run_to_block(2);

1068

1

            // Assert current slot gets updated

1069

1

            assert_eq!(current_slot(), 1u64);

1070

1

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

1071

1

            assert_eq!(

1072

1

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

1073

1

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

1074

1

);

1075

1

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

1076

1

            assert_eq!(

1077

1

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

1078

1

                Some(100.into())

1079

1

);

1080

1

            assert_eq!(

1081

1

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

1082

1

                Some(100.into())

1083

1

);

1084

1

            assert_eq!(

1085

1

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

1086

1

                None

1087

1

);

1088

1

            assert_eq!(

1089

1

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

1090

1

                None

1091

1

);

1092

1093

            // We change invulnerables

1094

            // We first need to set the keys

1095

1

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

1096

1

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

1097

1

1098

1

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

1099

1

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

1100

1

1101

1

            // Set CHARLIE and DAVE keys

1102

1

            assert_ok!(Session::set_keys(

1103

1

                origin_of(CHARLIE.into()),

1104

1

                crate::SessionKeys { nimbus: charlie_id },

1105

1

                vec![]

1106

1

));

1107

1

            assert_ok!(Session::set_keys(

1108

1

                origin_of(DAVE.into()),

1109

1

                crate::SessionKeys { nimbus: dave_id },

1110

1

                vec![]

1111

1

));

1112

1113

            // Set new invulnerables

1114

1

            assert_ok!(Invulnerables::add_invulnerable(

1115

1

                root_origin(),

1116

1

                CHARLIE.into()

1117

1

));

1118

1

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

1119

1120

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

1121

1

            run_to_session(1u32);

1122

1

            let author = get_orchestrator_current_author().unwrap();

1123

1

1124

1

            assert_eq!(current_author(), author);

1125

1

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

1126

1

            assert_eq!(

1127

1

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

1128

1

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

1129

1

);

1130

1

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

1131

1

            assert_eq!(

1132

1

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

1133

1

                None

1134

1

);

1135

1

            assert_eq!(

1136

1

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

1137

1

                Some(1001.into())

1138

1

);

1139

1140

            // Invulnerables should have triggered on new session authorities change

1141

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

1142

1

            run_to_session(2u32);

1143

1

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

1144

1

            let assignment = CollatorAssignment::collator_container_chain();

1145

1

            assert_eq!(

1146

1

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

1147

1

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

1148

1

);

1149

1150

1

            assert_eq!(

1151

1

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

1152

1

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

1153

1

);

1154

1

            assert_eq!(

1155

1

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

1156

1

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

1157

1

);

1158

1

            assert_eq!(

1159

1

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

1160

1

                Some(1001.into())

1161

1

);

1162

1

            assert_eq!(

1163

1

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

1164

1

                Some(1001.into())

1165

1

);

1166

1167

            // Remove BOB

1168

1

            assert_ok!(Invulnerables::remove_invulnerable(

1169

1

                root_origin(),

1170

1

                BOB.into()

1171

1

));

1172

1173

1

            run_to_session(3u32);

1174

1

            assert_eq!(

1175

1

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

1176

1

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

1177

1

);

1178

1

            assert_eq!(

1179

1

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

1180

1

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

1181

1

);

1182

1

            assert_eq!(

1183

1

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

1184

1

                Some(100.into())

1185

1

);

1186

1

            assert_eq!(

1187

1

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

1188

1

                None

1189

1

);

1190

1191

1

            run_to_session(4u32);

1192

1

            assert_eq!(

1193

1

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

1194

1

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

1195

1

);

1196

1

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

1197

1

            assert_eq!(

1198

1

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

1199

1

                None

1200

1

);

1201

1

            assert_eq!(

1202

1

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

1203

1

                None

1204

1

);

1205

1

});

1206

1

1207

1208

#[test]

1209

1

fn test_consensus_runtime_api() {

1210

1

    ExtBuilder::default()

1211

1

        .with_balances(vec![

1212

1

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

1213

1

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

1214

1

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

1215

1

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

1216

1

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

1217

1

])

1218

1

        .with_empty_parachains(vec![1001, 1002])

1219

1

        .build()

1220

1

        .execute_with(|| {

1221

1

            run_to_block(2);

1222

1

1223

1

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

1224

1

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

1225

1

1226

1

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

1227

1

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

1228

1

1229

1

            assert_eq!(

1230

1

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

1231

1

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

1232

1

);

1233

1

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

1234

1

            assert_eq!(

1235

1

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

1236

1

                Some(100.into())

1237

1

);

1238

1

            assert_eq!(

1239

1

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

1240

1

                Some(100.into())

1241

1

);

1242

1

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

1243

1

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

1244

1245

            // Set CHARLIE and DAVE keys

1246

1

            assert_ok!(Session::set_keys(

1247

1

                origin_of(CHARLIE.into()),

1248

1

                crate::SessionKeys {

1249

1

                    nimbus: charlie_id.clone(),

1250

1

},

1251

1

                vec![]

1252

1

));

1253

1

            assert_ok!(Session::set_keys(

1254

1

                origin_of(DAVE.into()),

1255

1

                crate::SessionKeys {

1256

1

                    nimbus: dave_id.clone(),

1257

1

},

1258

1

                vec![]

1259

1

));

1260

1261

            // Set new invulnerables

1262

1

            assert_ok!(Invulnerables::add_invulnerable(

1263

1

                root_origin(),

1264

1

                CHARLIE.into()

1265

1

));

1266

1

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

1267

1268

1

            run_to_session(2u32);

1269

1

            assert_eq!(

1270

1

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

1271

1

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

1272

1

);

1273

1

            assert_eq!(

1274

1

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

1275

1

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

1276

1

);

1277

1

            assert_eq!(

1278

1

                Runtime::check_para_id_assignment(alice_id),

1279

1

                Some(100.into())

1280

1

);

1281

1

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

1282

1

            assert_eq!(

1283

1

                Runtime::check_para_id_assignment(charlie_id),

1284

1

                Some(1001.into())

1285

1

);

1286

1

            assert_eq!(

1287

1

                Runtime::check_para_id_assignment(dave_id),

1288

1

                Some(1001.into())

1289

1

);

1290

1

});

1291

1

1292

1293

#[test]

1294

1

fn test_consensus_runtime_api_session_changes() {

1295

1

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

1296

1

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

1297

1

    // if we can predict correctly

1298

1

    ExtBuilder::default()

1299

1

        .with_balances(vec![

1300

1

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

1301

1

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

1302

1

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

1303

1

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

1304

1

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

1305

1

])

1306

1

        .with_empty_parachains(vec![1001, 1002])

1307

1

        .build()

1308

1

        .execute_with(|| {

1309

1

            run_to_block(2);

1310

1

1311

1

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

1312

1

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

1313

1

1314

1

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

1315

1

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

1316

1

1317

1

            assert_eq!(

1318

1

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

1319

1

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

1320

1

);

1321

1

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

1322

1

            assert_eq!(

1323

1

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

1324

1

                Some(100.into())

1325

1

);

1326

1

            assert_eq!(

1327

1

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

1328

1

                Some(100.into())

1329

1

);

1330

1

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

1331

1

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

1332

1333

            // Set CHARLIE and DAVE keys

1334

1

            assert_ok!(Session::set_keys(

1335

1

                origin_of(CHARLIE.into()),

1336

1

                crate::SessionKeys {

1337

1

                    nimbus: charlie_id.clone(),

1338

1

},

1339

1

                vec![]

1340

1

));

1341

1

            assert_ok!(Session::set_keys(

1342

1

                origin_of(DAVE.into()),

1343

1

                crate::SessionKeys {

1344

1

                    nimbus: dave_id.clone(),

1345

1

},

1346

1

                vec![]

1347

1

));

1348

1349

            // Set new invulnerables

1350

1

            assert_ok!(Invulnerables::add_invulnerable(

1351

1

                root_origin(),

1352

1

                CHARLIE.into()

1353

1

));

1354

1

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

1355

1356

1

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

1357

1

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

1358

1

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

1359

1

            // edge of a session change

1360

1

            run_to_block(session_two_edge - 2);

1361

1

1362

1

            assert_eq!(

1363

1

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

1364

1

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

1365

1

);

1366

1

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

1367

1

            assert_eq!(

1368

1

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

1369

1

                Some(100.into())

1370

1

);

1371

1

            assert_eq!(

1372

1

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

1373

1

                Some(100.into())

1374

1

);

1375

1

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

1376

1

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

1377

1378

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

1379

            // authorities of the next block!

1380

1

            run_to_block(session_two_edge - 1);

1381

1

            assert_eq!(

1382

1

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

1383

1

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

1384

1

);

1385

1

            assert_eq!(

1386

1

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

1387

1

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

1388

1

);

1389

1

            assert_eq!(

1390

1

                Runtime::check_para_id_assignment(alice_id),

1391

1

                Some(100.into())

1392

1

);

1393

1

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

1394

1

            assert_eq!(

1395

1

                Runtime::check_para_id_assignment(charlie_id),

1396

1

                Some(1001.into())

1397

1

);

1398

1

            assert_eq!(

1399

1

                Runtime::check_para_id_assignment(dave_id),

1400

1

                Some(1001.into())

1401

1

);

1402

1

});

1403

1

1404

1405

#[test]

1406

1

fn test_consensus_runtime_api_next_session() {

1407

1

    ExtBuilder::default()

1408

1

        .with_balances(vec![

1409

1

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

1410

1

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

1411

1

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

1412

1

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

1413

1

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

1414

1

])

1415

1

        .with_empty_parachains(vec![1001, 1002])

1416

1

        .build()

1417

1

        .execute_with(|| {

1418

1

            run_to_block(2);

1419

1

1420

1

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

1421

1

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

1422

1

1423

1

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

1424

1

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

1425

1

1426

1

            assert_eq!(

1427

1

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

1428

1

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

1429

1

);

1430

1

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

1431

1

            assert_eq!(

1432

1

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

1433

1

                Some(100.into())

1434

1

);

1435

1

            assert_eq!(

1436

1

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

1437

1

                Some(100.into())

1438

1

);

1439

1

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

1440

1

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

1441

1442

            // In the next session the assignment will not change

1443

1

            assert_eq!(

1444

1

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

1445

1

                Some(100.into())

1446

1

);

1447

1

            assert_eq!(

1448

1

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

1449

1

                Some(100.into())

1450

1

);

1451

1

            assert_eq!(

1452

1

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

1453

1

                None,

1454

1

);

1455

1

            assert_eq!(

1456

1

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

1457

1

                None,

1458

1

);

1459

1460

            // Set CHARLIE and DAVE keys

1461

1

            assert_ok!(Session::set_keys(

1462

1

                origin_of(CHARLIE.into()),

1463

1

                crate::SessionKeys {

1464

1

                    nimbus: charlie_id.clone(),

1465

1

},

1466

1

                vec![]

1467

1

));

1468

1

            assert_ok!(Session::set_keys(

1469

1

                origin_of(DAVE.into()),

1470

1

                crate::SessionKeys {

1471

1

                    nimbus: dave_id.clone(),

1472

1

},

1473

1

                vec![]

1474

1

));

1475

1476

            // Set new invulnerables

1477

1

            assert_ok!(Invulnerables::add_invulnerable(

1478

1

                root_origin(),

1479

1

                CHARLIE.into()

1480

1

));

1481

1

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

1482

1483

1

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

1484

1

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

1485

1

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

1486

1

            // edge of a session change

1487

1

            run_to_block(session_two_edge - 2);

1488

1

1489

1

            assert_eq!(

1490

1

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

1491

1

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

1492

1

);

1493

1

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

1494

1

            assert_eq!(

1495

1

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

1496

1

                Some(100.into())

1497

1

);

1498

1

            assert_eq!(

1499

1

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

1500

1

                Some(100.into())

1501

1

);

1502

1

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

1503

1

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

1504

1505

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

1506

1

            assert_eq!(

1507

1

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

1508

1

                Some(100.into())

1509

1

);

1510

1

            assert_eq!(

1511

1

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

1512

1

                Some(100.into())

1513

1

);

1514

1

            assert_eq!(

1515

1

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

1516

1

                Some(1001.into()),

1517

1

);

1518

1

            assert_eq!(

1519

1

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

1520

1

                Some(1001.into()),

1521

1

);

1522

1523

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

1524

            // authorities of the next block!

1525

1

            run_to_block(session_two_edge - 1);

1526

1

            assert_eq!(

1527

1

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

1528

1

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

1529

1

);

1530

1

            assert_eq!(

1531

1

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

1532

1

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

1533

1

);

1534

1

            assert_eq!(

1535

1

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

1536

1

                Some(100.into())

1537

1

);

1538

1

            assert_eq!(

1539

1

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

1540

1

                Some(100.into())

1541

1

);

1542

1

            assert_eq!(

1543

1

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

1544

1

                Some(1001.into())

1545

1

);

1546

1

            assert_eq!(

1547

1

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

1548

1

                Some(1001.into())

1549

1

);

1550

1551

            // check_para_id_assignment_next_session returns the same value as check_para_id_assignment

1552

            // because we are on a session boundary

1553

1

            assert_eq!(

1554

1

                Runtime::check_para_id_assignment_next_session(alice_id),

1555

1

                Some(100.into())

1556

1

);

1557

1

            assert_eq!(

1558

1

                Runtime::check_para_id_assignment_next_session(bob_id),

1559

1

                Some(100.into())

1560

1

);

1561

1

            assert_eq!(

1562

1

                Runtime::check_para_id_assignment_next_session(charlie_id),

1563

1

                Some(1001.into())

1564

1

);

1565

1

            assert_eq!(

1566

1

                Runtime::check_para_id_assignment_next_session(dave_id),

1567

1

                Some(1001.into())

1568

1

);

1569

1

});

1570

1

1571

1572

#[test]

1573

1

fn test_author_noting_self_para_id_not_noting() {

1574

1

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

1575

1

        let mut sproof = ParaHeaderSproofBuilder::default();

1576

1

        let slot: u64 = 5;

1577

1

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

1578

1

        let s = ParaHeaderSproofBuilderItem {

1579

1

            para_id: self_para,

1580

1

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

1581

1

                parent_hash: Default::default(),

1582

1

                number: Default::default(),

1583

1

                state_root: Default::default(),

1584

1

                extrinsics_root: Default::default(),

1585

1

                digest: sp_runtime::generic::Digest {

1586

1

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

1587

1

},

1588

1

}),

1589

1

};

1590

1

        sproof.items.push(s);

1591

1

1592

1

        set_author_noting_inherent_data(sproof);

1593

1

1594

1

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

1595

1

});

1596

1

1597

1598

#[test]

1599

1

fn test_author_noting_not_self_para() {

1600

1

    ExtBuilder::default()

1601

1

        .with_balances(vec![

1602

1

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

1603

1

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

1604

1

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

1605

1

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

1606

1

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

1607

1

])

1608

1

        .with_collators(vec![

1609

1

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

1610

1

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

1611

1

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

1612

1

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

1613

1

])

1614

1

        .with_empty_parachains(vec![1001, 1002])

1615

1

        .build()

1616

1

        .execute_with(|| {

1617

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1618

1

            let slot: u64 = 5;

1619

1

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

1620

1

1621

1

            // Charlie and Dave to 1001

1622

1

            let assignment = CollatorAssignment::collator_container_chain();

1623

1

            assert_eq!(

1624

1

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

1625

1

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

1626

1

);

1627

1628

1

            let s = ParaHeaderSproofBuilderItem {

1629

1

                para_id: other_para,

1630

1

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

1631

1

                    parent_hash: Default::default(),

1632

1

                    number: 1,

1633

1

                    state_root: Default::default(),

1634

1

                    extrinsics_root: Default::default(),

1635

1

                    digest: sp_runtime::generic::Digest {

1636

1

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

1637

1

},

1638

1

}),

1639

1

};

1640

1

            sproof.items.push(s);

1641

1

1642

1

            set_author_noting_inherent_data(sproof);

1643

1

1644

1

            assert_eq!(

1645

1

                AuthorNoting::latest_author(other_para),

1646

1

                Some(ContainerChainBlockInfo {

1647

1

                    block_number: 1,

1648

1

                    author: AccountId::from(DAVE),

1649

1

                    latest_slot_number: 0.into(),

1650

1

})

1651

1

);

1652

1

});

1653

1

1654

1655

#[test]

1656

1

fn test_author_noting_set_author_and_kill_author_data() {

1657

1

    ExtBuilder::default()

1658

1

        .with_balances(vec![

1659

1

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

1660

1

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

1661

1

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

1662

1

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

1663

1

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

1664

1

])

1665

1

        .with_collators(vec![

1666

1

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

1667

1

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

1668

1

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

1669

1

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

1670

1

])

1671

1

        .with_empty_parachains(vec![1001, 1002])

1672

1

        .build()

1673

1

        .execute_with(|| {

1674

1

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

1675

1

1676

1

            assert_ok!(AuthorNoting::set_author(

1677

1

                root_origin(),

1678

1

                other_para,

1679

1

1,

1680

1

                AccountId::from(DAVE),

1681

1

                1.into()

1682

1

));

1683

1684

1

            assert_eq!(

1685

1

                AuthorNoting::latest_author(other_para),

1686

1

                Some(ContainerChainBlockInfo {

1687

1

                    block_number: 1,

1688

1

                    author: AccountId::from(DAVE),

1689

1

                    latest_slot_number: 1.into(),

1690

1

})

1691

1

);

1692

1693

1

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

1694

1695

1

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

1696

1

});

1697

1

1698

1699

#[test]

1700

1

fn test_author_noting_set_author_and_kill_author_data_bad_origin() {

1701

1

    ExtBuilder::default()

1702

1

        .with_balances(vec![

1703

1

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

1704

1

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

1705

1

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

1706

1

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

1707

1

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

1708

1

])

1709

1

        .with_collators(vec![

1710

1

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

1711

1

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

1712

1

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

1713

1

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

1714

1

])

1715

1

        .with_empty_parachains(vec![1001, 1002])

1716

1

        .build()

1717

1

        .execute_with(|| {

1718

1

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

1719

1

1720

1

            assert_noop!(

1721

1

                AuthorNoting::set_author(

1722

1

                    origin_of(ALICE.into()),

1723

1

                    other_para,

1724

1

1,

1725

1

                    AccountId::from(DAVE),

1726

1

                    1.into()

1727

1

),

1728

1

                BadOrigin

1729

1

);

1730

1731

1

            assert_noop!(

1732

1

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

1733

1

                BadOrigin

1734

1

);

1735

1

});

1736

1

1737

1738

#[test]

1739

1

fn test_author_noting_runtime_api() {

1740

1

    ExtBuilder::default()

1741

1

        .with_balances(vec![

1742

1

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

1743

1

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

1744

1

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

1745

1

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

1746

1

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

1747

1

])

1748

1

        .with_collators(vec![

1749

1

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

1750

1

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

1751

1

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

1752

1

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

1753

1

])

1754

1

        .with_empty_parachains(vec![1001, 1002])

1755

1

        .build()

1756

1

        .execute_with(|| {

1757

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1758

1

            let slot: u64 = 5;

1759

1

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

1760

1

1761

1

            // Charlie and Dave to 1001

1762

1

            let assignment = CollatorAssignment::collator_container_chain();

1763

1

            assert_eq!(

1764

1

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

1765

1

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

1766

1

);

1767

1768

1

            let s = ParaHeaderSproofBuilderItem {

1769

1

                para_id: other_para,

1770

1

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

1771

1

                    parent_hash: Default::default(),

1772

1

                    number: 1,

1773

1

                    state_root: Default::default(),

1774

1

                    extrinsics_root: Default::default(),

1775

1

                    digest: sp_runtime::generic::Digest {

1776

1

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

1777

1

},

1778

1

}),

1779

1

};

1780

1

            sproof.items.push(s);

1781

1

1782

1

            set_author_noting_inherent_data(sproof);

1783

1

1784

1

            assert_eq!(

1785

1

                AuthorNoting::latest_author(other_para),

1786

1

                Some(ContainerChainBlockInfo {

1787

1

                    block_number: 1,

1788

1

                    author: AccountId::from(DAVE),

1789

1

                    latest_slot_number: 0.into(),

1790

1

})

1791

1

);

1792

1793

1

            assert_eq!(

1794

1

                Runtime::latest_author(other_para),

1795

1

                Some(AccountId::from(DAVE))

1796

1

);

1797

1

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

1798

1

});

1799

1

1800

1801

#[test]

1802

1

fn test_collator_assignment_rotation() {

1803

1

    ExtBuilder::default()

1804

1

        .with_balances(vec![

1805

1

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

1806

1

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

1807

1

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

1808

1

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

1809

1

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

1810

1

])

1811

1

        .with_collators(vec![

1812

1

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

1813

1

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

1814

1

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

1815

1

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

1816

1

])

1817

1

        .with_empty_parachains(vec![1001, 1002])

1818

1

        .build()

1819

1

        .execute_with(|| {

1820

1

            // Charlie and Dave to 1001

1821

1

            let assignment = CollatorAssignment::collator_container_chain();

1822

1

            let initial_assignment = assignment.clone();

1823

1

            assert_eq!(

1824

1

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

1825

1

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

1826

1

);

1827

1828

1

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

1829

1

            run_to_session(rotation_period - 2);

1830

1

            set_parachain_inherent_data_random_seed([1; 32]);

1831

1

            run_block();

1832

1

1833

1

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

1834

1835

1

            run_to_session(rotation_period - 1);

1836

1

            assert_eq!(

1837

1

                CollatorAssignment::collator_container_chain(),

1838

1

                initial_assignment,

1839

1

);

1840

1

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

1841

1842

1

            run_to_session(rotation_period);

1843

1

            // Assignment changed

1844

1

            assert_ne!(

1845

1

                CollatorAssignment::collator_container_chain(),

1846

1

                initial_assignment,

1847

1

);

1848

1

});

1849

1

1850

1851

#[test]

1852

1

fn session_keys_key_type_id() {

1853

1

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

1854

1

1855

1856

#[test]

1857

1

fn test_session_keys_with_authority_mapping() {

1858

1

    ExtBuilder::default()

1859

1

        .with_balances(vec![

1860

1

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

1861

1

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

1862

1

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

1863

1

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

1864

1

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

1865

1

])

1866

1

        .with_empty_parachains(vec![1001, 1002])

1867

1

        .build()

1868

1

        .execute_with(|| {

1869

1

            run_to_block(2);

1870

1

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

1871

1

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

1872

1

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

1873

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1874

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1875

1

1876

1

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

1877

1

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

1878

1

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

1879

1880

            // Everything should match to aura

1881

1

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

1882

1883

            // Change Alice and Bob keys to something different

1884

            // for now lets change it to alice_2 and bob_2

1885

1

            assert_ok!(Session::set_keys(

1886

1

                origin_of(ALICE.into()),

1887

1

                crate::SessionKeys {

1888

1

                    nimbus: alice_id_2.clone(),

1889

1

},

1890

1

                vec![]

1891

1

));

1892

1

            assert_ok!(Session::set_keys(

1893

1

                origin_of(BOB.into()),

1894

1

                crate::SessionKeys {

1895

1

                    nimbus: bob_id_2.clone(),

1896

1

},

1897

1

                vec![]

1898

1

));

1899

1900

1

            run_to_session(1u32);

1901

1

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

1902

1

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

1903

1

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

1904

1

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

1905

1906

1

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

1907

1

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

1908

1

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

1909

1

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

1910

1911

            // Everything should match to aura

1912

1

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

1913

//

1914

1915

1

            run_to_session(2u32);

1916

1

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

1917

1918

1

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

1919

1

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

1920

1

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

1921

1

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

1922

1923

1

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

1924

1

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

1925

1

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

1926

1

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

1927

1928

            // Everything should match to aura

1929

1

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

1930

1

});

1931

1

1932

1933

#[test]

1934

1

fn test_session_keys_with_authority_assignment() {

1935

1

    ExtBuilder::default()

1936

1

        .with_balances(vec![

1937

1

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

1938

1

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

1939

1

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

1940

1

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

1941

1

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

1942

1

])

1943

1

        .with_empty_parachains(vec![1001, 1002])

1944

1

        .build()

1945

1

        .execute_with(|| {

1946

1

            run_to_block(2);

1947

1

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

1948

1

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

1949

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1950

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1951

1

1952

1

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

1953

1

            assert_eq!(

1954

1

                key_mapping_session_0.orchestrator_chain,

1955

1

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

1956

1

);

1957

1

            assert_eq!(

1958

1

                CollatorAssignment::collator_container_chain().orchestrator_chain,

1959

1

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

1960

1

);

1961

1962

1

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

1963

1

            assert_eq!(key_mapping_session_1, key_mapping_session_0,);

1964

1

            let old_assignment_session_1 =

1965

1

                CollatorAssignment::pending_collator_container_chain().unwrap();

1966

1

            assert_eq!(

1967

1

                old_assignment_session_1,

1968

1

                CollatorAssignment::collator_container_chain(),

1969

1

);

1970

1971

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2);

1972

1

            assert!(key_mapping_session_2.is_none());

1973

1974

            // Everything should match to aura

1975

1

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

1976

1977

            // Change Alice and Bob keys to something different

1978

            // for now lets change it to alice_2 and bob_2

1979

1

            assert_ok!(Session::set_keys(

1980

1

                origin_of(ALICE.into()),

1981

1

                crate::SessionKeys {

1982

1

                    nimbus: alice_id_2.clone(),

1983

1

},

1984

1

                vec![]

1985

1

));

1986

1

            assert_ok!(Session::set_keys(

1987

1

                origin_of(BOB.into()),

1988

1

                crate::SessionKeys {

1989

1

                    nimbus: bob_id_2.clone(),

1990

1

},

1991

1

                vec![]

1992

1

));

1993

1994

1

            run_to_session(1u32);

1995

1

            let old_key_mapping_session_1 = key_mapping_session_1;

1996

1

1997

1

            // Session 0 got removed

1998

1

            let key_mapping_session_0 = AuthorityAssignment::collator_container_chain(0);

1999

1

            assert!(key_mapping_session_0.is_none());

2000

2001

            // The values at session 1 did not change

2002

1

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

2003

1

            assert_eq!(key_mapping_session_1, old_key_mapping_session_1,);

2004

1

            assert_eq!(

2005

1

                CollatorAssignment::collator_container_chain(),

2006

1

                old_assignment_session_1,

2007

1

);

2008

2009

            // Session 2 uses the new keys

2010

1

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

2011

1

            assert_eq!(

2012

1

                key_mapping_session_2.orchestrator_chain,

2013

1

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

2014

1

);

2015

1

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

2016

2017

1

            let key_mapping_session_3 = AuthorityAssignment::collator_container_chain(3);

2018

1

            assert!(key_mapping_session_3.is_none());

2019

2020

            // Everything should match to aura

2021

1

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

2022

2023

1

            run_to_session(2u32);

2024

1

2025

1

            // Session 1 got removed

2026

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1);

2027

1

            assert!(key_mapping_session_1.is_none());

2028

2029

            // Session 2 uses the new keys

2030

1

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

2031

1

            assert_eq!(

2032

1

                key_mapping_session_2.orchestrator_chain,

2033

1

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

2034

1

);

2035

1

            assert_eq!(

2036

1

                old_assignment_session_1,

2037

1

                CollatorAssignment::collator_container_chain(),

2038

1

);

2039

2040

            // Session 3 uses the new keys

2041

1

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

2042

1

            assert_eq!(

2043

1

                key_mapping_session_3.orchestrator_chain,

2044

1

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

2045

1

);

2046

1

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

2047

2048

1

            let key_mapping_session_4 = AuthorityAssignment::collator_container_chain(4);

2049

1

            assert!(key_mapping_session_4.is_none());

2050

2051

            // Everything should match to aura

2052

1

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

2053

1

});

2054

1

2055

2056

2

fn call_transfer(

2057

2

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

2058

2

    value: u128,

2059

2

) -> RuntimeCall {

2060

2

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

2061

2

2062

2063

#[test]

2064

1

fn test_proxy_any() {

2065

1

    ExtBuilder::default()

2066

1

        .with_balances(vec![

2067

1

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

2068

1

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

2069

1

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

2070

1

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

2071

1

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

2072

1

])

2073

1

        .build()

2074

1

        .execute_with(|| {

2075

1

            run_to_block(2);

2076

1

2077

1

            let delay = 0;

2078

1

            assert_ok!(Proxy::add_proxy(

2079

1

                origin_of(ALICE.into()),

2080

1

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

2081

1

                ProxyType::Any,

2082

1

                delay

2083

1

));

2084

2085

1

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

2086

1

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

2087

1

            assert_ok!(Proxy::proxy(

2088

1

                origin_of(BOB.into()),

2089

1

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

2090

1

                None,

2091

1

                call

2092

1

));

2093

1

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

2094

1

2095

1

            assert_eq!(balance_after, balance_before + 200_000);

2096

1

});

2097

1

2098

2099

#[test]

2100

1

fn test_proxy_non_transfer() {

2101

1

    ExtBuilder::default()

2102

1

        .with_balances(vec![

2103

1

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

2104

1

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

2105

1

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

2106

1

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

2107

1

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

2108

1

])

2109

1

        .build()

2110

1

        .execute_with(|| {

2111

1

            run_to_block(2);

2112

1

2113

1

            let delay = 0;

2114

1

            assert_ok!(Proxy::add_proxy(

2115

1

                origin_of(ALICE.into()),

2116

1

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

2117

1

                ProxyType::NonTransfer,

2118

1

                delay

2119

1

));

2120

2121

1

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

2122

1

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

2123

1

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

2124

1

            assert_ok!(Proxy::proxy(

2125

1

                origin_of(BOB.into()),

2126

1

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

2127

1

                None,

2128

1

                call

2129

1

));

2130

1

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

2131

1

2132

1

            assert_eq!(balance_after, balance_before);

2133

1

});

2134

1

2135

2136

#[test]

2137

1

fn test_proxy_utility() {

2138

1

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

2139

1

    // subcalls don't allow to circumvent filters.

2140

1

2141

1

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

2142

1

    match ProxyType::Any {

2143

        ProxyType::Any

2144

        | ProxyType::NonTransfer

2145

        | ProxyType::Governance

2146

        | ProxyType::Staking

2147

        | ProxyType::CancelProxy

2148

        | ProxyType::Balances

2149

        | ProxyType::Registrar

2150

        | ProxyType::SudoRegistrar

2151

1

        | ProxyType::SessionKeyManagement => (),

2152

1

};

2153

1

2154

1

    // All except for any

2155

1

    let proxy_types = &[

2156

1

        ProxyType::NonTransfer,

2157

1

        ProxyType::Governance,

2158

1

        ProxyType::Staking,

2159

1

        ProxyType::CancelProxy,

2160

1

        ProxyType::Balances,

2161

1

        ProxyType::Registrar,

2162

1

        ProxyType::SudoRegistrar,

2163

1

        ProxyType::SessionKeyManagement,

2164

1

];

2165

2166

9

    for &proxy_type in proxy_types {

2167

8

        ExtBuilder::default()

2168

8

            .with_balances(vec![

2169

8

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

2170

8

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

2171

8

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

2172

8

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

2173

8

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

2174

8

])

2175

8

            .with_collators(vec![

2176

8

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

2177

8

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

2178

8

])

2179

8

            .with_sudo(AccountId::from(ALICE))

2180

8

            .build()

2181

8

            .execute_with(|| {

2182

8

                assert_ok!(Proxy::add_proxy(

2183

8

                    origin_of(ALICE.into()),

2184

8

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

2185

8

                    proxy_type,

2186

8

2187

8

));

2188

2189

8

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

2190

8

2191

8

                assert_ok!(Proxy::proxy(

2192

8

                    origin_of(BOB.into()),

2193

8

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

2194

8

                    None,

2195

8

                    Box::new(

2196

8

                        pallet_sudo::Call::sudo {

2197

8

                            call: Box::new(

2198

8

                                pallet_utility::Call::batch {

2199

8

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

2200

8

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

2201

8

                                        new_free: 42424242424242

2202

8

2203

8

                                    .into()]

2204

8

2205

8

                                .into()

2206

8

2207

8

2208

8

                        .into()

2209

8

2210

8

));

2211

2212

8

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

2213

8

});

2214

8

2215

1

2216

2217

#[test]

2218

1

fn check_well_known_keys() {

2219

    use frame_support::traits::PalletInfo;

2220

2221

    // Pallet is named "Paras" in Polkadot.

2222

1

    assert_eq!(

2223

1

        well_known_keys::PARAS_HEADS_INDEX,

2224

1

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

2225

1

);

2226

2227

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

2228

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

2229

1

    assert_eq!(

2230

1

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

2231

1

        Some("AuthorityAssignment")

2232

1

);

2233

1

    assert_eq!(

2234

1

        well_known_keys::AUTHORITY_ASSIGNMENT_PREFIX,

2235

1

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

2236

1

);

2237

2238

1

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

2239

1

    assert_eq!(

2240

1

        well_known_keys::SESSION_INDEX,

2241

1

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

2242

1

);

2243

1

2244

2245

#[test]

2246

1

fn test_staking_no_candidates_in_genesis() {

2247

1

    ExtBuilder::default()

2248

1

        .with_balances(vec![

2249

1

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

2250

1

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

2251

1

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

2252

1

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

2253

1

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

2254

1

])

2255

1

        .with_collators(vec![

2256

1

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

2257

1

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

2258

1

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

2259

1

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

2260

1

])

2261

1

        .with_empty_parachains(vec![1001, 1002])

2262

1

        .build()

2263

1

        .execute_with(|| {

2264

1

            run_to_block(2);

2265

1

2266

1

            let initial_candidates =

2267

1

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

2268

1

2269

1

            assert_eq!(initial_candidates, vec![]);

2270

1

});

2271

1

2272

2273

#[test]

2274

1

fn test_staking_join() {

2275

1

    ExtBuilder::default()

2276

1

        .with_balances(vec![

2277

1

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

2278

1

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

2279

1

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

2280

1

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

2281

1

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

2282

1

])

2283

1

        .with_collators(vec![

2284

1

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

2285

1

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

2286

1

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

2287

1

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

2288

1

])

2289

1

        .with_empty_parachains(vec![1001, 1002])

2290

1

        .build()

2291

1

        .execute_with(|| {

2292

1

            run_to_block(2);

2293

1

2294

1

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

2295

1

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

2296

1

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

2297

1

            assert_ok!(PooledStaking::request_delegate(

2298

1

                origin_of(ALICE.into()),

2299

1

                ALICE.into(),

2300

1

                ActivePoolKind::AutoCompounding,

2301

1

                stake

2302

1

));

2303

2304

            // Immediately after joining, Alice is the top candidate

2305

1

            let eligible_candidates =

2306

1

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

2307

1

            assert_eq!(

2308

1

                eligible_candidates,

2309

1

                vec![EligibleCandidate {

2310

1

                    candidate: ALICE.into(),

2311

1

                    stake

2312

1

}]

2313

1

);

2314

2315

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

2316

1

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

2317

1

            assert_eq!(balance_before - balance_after, stake);

2318

1

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

2319

1

});

2320

1

2321

2322

#[test]

2323

1

fn test_staking_join_no_keys_registered() {

2324

1

    ExtBuilder::default()

2325

1

        .with_balances(vec![

2326

1

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

2327

1

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

2328

1

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

2329

1

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

2330

1

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

2331

1

])

2332

1

        .with_collators(vec![

2333

1

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

2334

1

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

2335

1

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

2336

1

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

2337

1

])

2338

1

        .with_empty_parachains(vec![

2339

1

            1001,

2340

1

            1002,

2341

1

])

2342

1

2343

1

        .build()

2344

1

        .execute_with(|| {

2345

1

            run_to_block(2);

2346

1

2347

1

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

2348

1

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

2349

1

            assert_ok!(Balances::transfer_allow_death(

2350

1

                origin_of(ALICE.into()),

2351

1

                new_account.clone().into(),

2352

1

                stake * 2

2353

1

));

2354

1

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

2355

1

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

2356

1

            assert_ok!(PooledStaking::request_delegate(

2357

1

                origin_of(new_account.clone()),

2358

1

                new_account.clone(),

2359

1

                ActivePoolKind::AutoCompounding,

2360

1

                stake

2361

1

));

2362

2363

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

2364

            // pallet_session, so it is not eligible

2365

1

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

2366

1

            let eligible_candidates =

2367

1

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

2368

1

2369

1

            assert_eq!(eligible_candidates, vec![]);

2370

2371

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

2372

1

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

2373

1

            assert_eq!(balance_before - balance_after, stake);

2374

1

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

2375

1

});

2376

1

2377

2378

#[test]

2379

1

fn test_staking_register_keys_after_joining() {

2380

1

    ExtBuilder::default()

2381

1

        .with_balances(vec![

2382

1

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

2383

1

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

2384

1

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

2385

1

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

2386

1

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

2387

1

])

2388

1

        .with_collators(vec![

2389

1

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

2390

1

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

2391

1

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

2392

1

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

2393

1

])

2394

1

        .with_empty_parachains(vec![

2395

1

            1001,

2396

1

            1002,

2397

1

])

2398

1

2399

1

        .build()

2400

1

        .execute_with(|| {

2401

1

            run_to_block(2);

2402

1

2403

1

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

2404

1

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

2405

1

            assert_ok!(Balances::transfer_allow_death(

2406

1

                origin_of(ALICE.into()),

2407

1

                new_account.clone().into(),

2408

1

                stake * 2

2409

1

));

2410

1

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

2411

1

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

2412

1

            assert_ok!(PooledStaking::request_delegate(

2413

1

                origin_of(new_account.clone()),

2414

1

                new_account.clone(),

2415

1

                ActivePoolKind::AutoCompounding,

2416

1

                stake

2417

1

));

2418

2419

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

2420

            // pallet_session, so it is not eligible

2421

1

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

2422

1

            let eligible_candidates =

2423

1

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

2424

1

            assert_eq!(eligible_candidates, vec![]);

2425

2426

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

2427

1

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

2428

1

            assert_eq!(balance_before - balance_after, stake);

2429

1

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

2430

2431

            // Now register the keys

2432

1

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

2433

1

            assert_ok!(Session::set_keys(

2434

1

                origin_of(new_account.clone()),

2435

1

                crate::SessionKeys {

2436

1

                    nimbus: new_account_id,

2437

1

},

2438

1

                vec![]

2439

1

));

2440

2441

            // Now eligible according to filter

2442

1

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

2443

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

2444

1

            let eligible_candidates =

2445

1

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

2446

1

            assert_eq!(eligible_candidates, vec![]);

2447

2448

            // Update candidate list

2449

1

            assert_ok!(PooledStaking::update_candidate_position(

2450

1

                origin_of(BOB.into()),

2451

1

                vec![new_account.clone()]

2452

1

));

2453

2454

            // Now it is eligible

2455

1

            let eligible_candidates =

2456

1

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

2457

1

            assert_eq!(

2458

1

                eligible_candidates,

2459

1

                vec![EligibleCandidate {

2460

1

                    candidate: new_account.clone(),

2461

1

                    stake

2462

1

}]

2463

1

);

2464

1

});

2465

1

2466

2467

#[test]

2468

1

fn test_staking_join_bad_origin() {

2469

1

    ExtBuilder::default()

2470

1

        .with_balances(vec![

2471

1

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

2472

1

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

2473

1

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

2474

1

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

2475

1

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

2476

1

])

2477

1

        .with_collators(vec![

2478

1

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

2479

1

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

2480

1

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

2481

1

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

2482

1

])

2483

1

        .with_empty_parachains(vec![1001, 1002])

2484

1

        .build()

2485

1

        .execute_with(|| {

2486

1

            run_to_block(2);

2487

1

2488

1

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

2489

1

            assert_noop!(

2490

1

                PooledStaking::request_delegate(

2491

1

                    root_origin(),

2492

1

                    ALICE.into(),

2493

1

                    ActivePoolKind::AutoCompounding,

2494

1

                    stake

2495

1

),

2496

1

                BadOrigin,

2497

1

);

2498

1

});

2499

1

2500

2501

#[test]

2502

1

fn test_staking_join_below_self_delegation_min() {

2503

1

    ExtBuilder::default()

2504

1

        .with_balances(vec![

2505

1

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

2506

1

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

2507

1

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

2508

1

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

2509

1

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

2510

1

])

2511

1

        .with_collators(vec![

2512

1

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

2513

1

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

2514

1

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

2515

1

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

2516

1

])

2517

1

        .with_empty_parachains(vec![1001, 1002])

2518

1

        .build()

2519

1

        .execute_with(|| {

2520

1

            run_to_block(2);

2521

1

2522

1

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

2523

1

            assert_ok!(PooledStaking::request_delegate(

2524

1

                origin_of(ALICE.into()),

2525

1

                ALICE.into(),

2526

1

                ActivePoolKind::AutoCompounding,

2527

1

                stake1

2528

1

));

2529

2530

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

2531

            // but the candidate is not eligible

2532

1

            let eligible_candidates =

2533

1

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

2534

1

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

2535

2536

1

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

2537

1

            assert_ok!(PooledStaking::request_delegate(

2538

1

                origin_of(ALICE.into()),

2539

1

                ALICE.into(),

2540

1

                ActivePoolKind::AutoCompounding,

2541

1

                stake2,

2542

1

));

2543

2544

            // Still below, missing 1 unit

2545

1

            let eligible_candidates =

2546

1

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

2547

1

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

2548

2549

1

            let stake3 = 1;

2550

1

            assert_ok!(PooledStaking::request_delegate(

2551

1

                origin_of(ALICE.into()),

2552

1

                ALICE.into(),

2553

1

                ActivePoolKind::AutoCompounding,

2554

1

                stake3,

2555

1

));

2556

2557

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

2558

1

            let eligible_candidates =

2559

1

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

2560

1

            assert_eq!(

2561

1

                eligible_candidates,

2562

1

                vec![EligibleCandidate {

2563

1

                    candidate: ALICE.into(),

2564

1

                    stake: stake1 + stake2 + stake3

2565

1

}],

2566

1

);

2567

1

});

2568

1

2569

2570

#[test]

2571

1

fn test_staking_join_no_self_delegation() {

2572

1

    ExtBuilder::default()

2573

1

        .with_balances(vec![

2574

1

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

2575

1

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

2576

1

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

2577

1

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

2578

1

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

2579

1

])

2580

1

        .with_collators(vec![

2581

1

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

2582

1

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

2583

1

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

2584

1

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

2585

1

])

2586

1

        .with_empty_parachains(vec![1001, 1002])

2587

1

        .build()

2588

1

        .execute_with(|| {

2589

1

            run_to_block(2);

2590

1

2591

1

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

2592

1

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

2593

1

            assert_ok!(PooledStaking::request_delegate(

2594

1

                origin_of(BOB.into()),

2595

1

                ALICE.into(),

2596

1

                ActivePoolKind::AutoCompounding,

2597

1

                stake,

2598

1

));

2599

2600

1

            let eligible_candidates =

2601

1

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

2602

1

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

2603

1

});

2604

1

2605

2606

#[test]

2607

1

fn test_staking_join_before_self_delegation() {

2608

1

    ExtBuilder::default()

2609

1

        .with_balances(vec![

2610

1

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

2611

1

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

2612

1

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

2613

1

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

2614

1

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

2615

1

])

2616

1

        .with_collators(vec![

2617

1

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

2618

1

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

2619

1

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

2620

1

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

2621

1

])

2622

1

        .with_empty_parachains(vec![1001, 1002])

2623

1

        .build()

2624

1

        .execute_with(|| {

2625

1

            run_to_block(2);

2626

1

2627

1

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

2628

1

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

2629

1

            assert_ok!(PooledStaking::request_delegate(

2630

1

                origin_of(BOB.into()),

2631

1

                ALICE.into(),

2632

1

                ActivePoolKind::AutoCompounding,

2633

1

                stake

2634

1

));

2635

2636

1

            let eligible_candidates =

2637

1

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

2638

1

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

2639

2640

1

            run_to_session(2);

2641

1

            assert_ok!(PooledStaking::execute_pending_operations(

2642

1

                origin_of(ALICE.into()),

2643

1

                vec![PendingOperationQuery {

2644

1

                    delegator: BOB.into(),

2645

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2646

1

                        candidate: ALICE.into(),

2647

1

                        at: 0,

2648

1

2649

1

}]

2650

1

            ),);

2651

2652

            // Now Alice joins with enough self-delegation

2653

1

            assert_ok!(PooledStaking::request_delegate(

2654

1

                origin_of(ALICE.into()),

2655

1

                ALICE.into(),

2656

1

                ActivePoolKind::AutoCompounding,

2657

1

                stake

2658

1

));

2659

2660

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

2661

1

            let eligible_candidates =

2662

1

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

2663

1

            assert_eq!(

2664

1

                eligible_candidates,

2665

1

                vec![EligibleCandidate {

2666

1

                    candidate: ALICE.into(),

2667

1

                    stake: stake * 2,

2668

1

}],

2669

1

);

2670

1

});

2671

1

2672

2673

#[test]

2674

1

fn test_staking_join_twice_in_same_block() {

2675

1

    ExtBuilder::default()

2676

1

        .with_balances(vec![

2677

1

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

2678

1

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

2679

1

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

2680

1

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

2681

1

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

2682

1

])

2683

1

        .with_collators(vec![

2684

1

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

2685

1

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

2686

1

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

2687

1

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

2688

1

])

2689

1

        .with_empty_parachains(vec![1001, 1002])

2690

1

        .build()

2691

1

        .execute_with(|| {

2692

1

            run_to_block(2);

2693

1

2694

1

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

2695

1

            assert_ok!(PooledStaking::request_delegate(

2696

1

                origin_of(ALICE.into()),

2697

1

                ALICE.into(),

2698

1

                ActivePoolKind::AutoCompounding,

2699

1

                stake1

2700

1

));

2701

2702

1

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

2703

1

            assert_ok!(PooledStaking::request_delegate(

2704

1

                origin_of(ALICE.into()),

2705

1

                ALICE.into(),

2706

1

                ActivePoolKind::AutoCompounding,

2707

1

                stake2

2708

1

));

2709

2710

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

2711

1

            let eligible_candidates =

2712

1

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

2713

1

2714

1

            assert_eq!(

2715

1

                eligible_candidates,

2716

1

                vec![EligibleCandidate {

2717

1

                    candidate: ALICE.into(),

2718

1

                    stake: stake1 + stake2,

2719

1

}]

2720

1

);

2721

2722

1

            run_to_session(2);

2723

1

2724

1

            assert_ok!(PooledStaking::execute_pending_operations(

2725

1

                origin_of(ALICE.into()),

2726

1

                vec![PendingOperationQuery {

2727

1

                    delegator: ALICE.into(),

2728

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2729

1

                        candidate: ALICE.into(),

2730

1

                        at: 0,

2731

1

2732

1

}]

2733

1

            ),);

2734

2735

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

2736

1

});

2737

1

2738

2739

#[test]

2740

1

fn test_staking_join_execute_before_time() {

2741

1

    ExtBuilder::default()

2742

1

        .with_balances(vec![

2743

1

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

2744

1

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

2745

1

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

2746

1

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

2747

1

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

2748

1

])

2749

1

        .with_collators(vec![

2750

1

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

2751

1

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

2752

1

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

2753

1

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

2754

1

])

2755

1

        .with_empty_parachains(vec![1001, 1002])

2756

1

        .build()

2757

1

        .execute_with(|| {

2758

1

            run_to_block(2);

2759

1

2760

1

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

2761

1

            assert_ok!(PooledStaking::request_delegate(

2762

1

                origin_of(ALICE.into()),

2763

1

                ALICE.into(),

2764

1

                ActivePoolKind::AutoCompounding,

2765

1

                stake

2766

1

));

2767

2768

            // Immediately after joining, Alice is the top candidate

2769

1

            let eligible_candidates =

2770

1

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

2771

1

            assert_eq!(

2772

1

                eligible_candidates,

2773

1

                vec![EligibleCandidate {

2774

1

                    candidate: ALICE.into(),

2775

1

                    stake

2776

1

}]

2777

1

);

2778

2779

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

2780

1

            let start_of_session_2 = session_to_block(2);

2781

1

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

2782

1

            run_to_block(start_of_session_2 - 2);

2783

1

            assert_noop!(

2784

1

                PooledStaking::execute_pending_operations(

2785

1

                    origin_of(ALICE.into()),

2786

1

                    vec![PendingOperationQuery {

2787

1

                        delegator: ALICE.into(),

2788

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

2789

1

                            candidate: ALICE.into(),

2790

1

                            at: 0,

2791

1

2792

1

}]

2793

1

),

2794

1

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

2795

1

);

2796

2797

1

            run_to_block(start_of_session_2);

2798

1

            assert_ok!(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

1

            ),);

2808

1

});

2809

1

2810

2811

#[test]

2812

1

fn test_staking_join_execute_any_origin() {

2813

1

    ExtBuilder::default()

2814

1

        .with_balances(vec![

2815

1

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

2816

1

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

2817

1

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

2818

1

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

2819

1

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

2820

1

])

2821

1

        .with_collators(vec![

2822

1

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

2823

1

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

2824

1

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

2825

1

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

2826

1

])

2827

1

        .with_empty_parachains(vec![1001, 1002])

2828

1

        .build()

2829

1

        .execute_with(|| {

2830

1

            run_to_block(2);

2831

1

2832

1

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

2833

1

            assert_ok!(PooledStaking::request_delegate(

2834

1

                origin_of(ALICE.into()),

2835

1

                ALICE.into(),

2836

1

                ActivePoolKind::AutoCompounding,

2837

1

                stake

2838

1

));

2839

2840

            // Immediately after joining, Alice is the top candidate

2841

1

            let eligible_candidates =

2842

1

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

2843

1

            assert_eq!(

2844

1

                eligible_candidates,

2845

1

                vec![EligibleCandidate {

2846

1

                    candidate: ALICE.into(),

2847

1

                    stake

2848

1

}]

2849

1

);

2850

2851

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

2852

1

            run_to_session(2);

2853

1

            // Anyone can execute pending operations for anyone else

2854

1

            assert_ok!(PooledStaking::execute_pending_operations(

2855

1

                origin_of(BOB.into()),

2856

1

                vec![PendingOperationQuery {

2857

1

                    delegator: ALICE.into(),

2858

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2859

1

                        candidate: ALICE.into(),

2860

1

                        at: 0,

2861

1

2862

1

}]

2863

1

            ),);

2864

1

});

2865

1

2866

2867

#[test]

2868

1

fn test_staking_join_execute_bad_origin() {

2869

1

    ExtBuilder::default()

2870

1

        .with_balances(vec![

2871

1

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

2872

1

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

2873

1

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

2874

1

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

2875

1

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

2876

1

])

2877

1

        .with_collators(vec![

2878

1

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

2879

1

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

2880

1

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

2881

1

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

2882

1

])

2883

1

        .with_empty_parachains(vec![1001, 1002])

2884

1

        .build()

2885

1

        .execute_with(|| {

2886

1

            run_to_block(2);

2887

1

2888

1

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

2889

1

            assert_ok!(PooledStaking::request_delegate(

2890

1

                origin_of(ALICE.into()),

2891

1

                ALICE.into(),

2892

1

                ActivePoolKind::AutoCompounding,

2893

1

                stake

2894

1

));

2895

2896

            // Immediately after joining, Alice is the top candidate

2897

1

            let eligible_candidates =

2898

1

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

2899

1

            assert_eq!(

2900

1

                eligible_candidates,

2901

1

                vec![EligibleCandidate {

2902

1

                    candidate: ALICE.into(),

2903

1

                    stake

2904

1

}]

2905

1

);

2906

2907

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

2908

1

            run_to_session(2);

2909

1

            assert_noop!(

2910

1

                PooledStaking::execute_pending_operations(

2911

1

                    root_origin(),

2912

1

                    vec![PendingOperationQuery {

2913

1

                        delegator: ALICE.into(),

2914

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

2915

1

                            candidate: ALICE.into(),

2916

1

                            at: 0,

2917

1

2918

1

}]

2919

1

),

2920

1

                BadOrigin,

2921

1

);

2922

1

});

2923

1

2924

2925

struct A {

2926

    delegator: AccountId,

2927

    candidate: AccountId,

2928

    target_pool: ActivePoolKind,

2929

    stake: u128,

2930

2931

2932

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

2933

9

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

2934

9

    ExtBuilder::default()

2935

9

        .with_balances(vec![

2936

9

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

2937

9

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

2938

9

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

2939

9

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

2940

9

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

2941

9

])

2942

9

        .with_collators(vec![

2943

9

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

2944

9

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

2945

9

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

2946

9

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

2947

9

])

2948

9

        .with_empty_parachains(vec![1001, 1002])

2949

9

        .build()

2950

9

        .execute_with(|| {

2951

9

            run_to_block(2);

2952

2953

9

            for op in ops.iter() {

2954

9

                assert_ok!(PooledStaking::request_delegate(

2955

9

                    origin_of(op.delegator.clone()),

2956

9

                    op.candidate.clone(),

2957

9

                    op.target_pool,

2958

9

                    op.stake,

2959

9

));

2960

2961

2962

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

2963

9

            run_to_session(2);

2964

2965

9

            for op in ops.iter() {

2966

9

                let operation = match op.target_pool {

2967

                    ActivePoolKind::AutoCompounding => {

2968

9

                        PendingOperationKey::JoiningAutoCompounding {

2969

9

                            candidate: op.candidate.clone(),

2970

9

                            at: 0,

2971

9

2972

2973

                    ActivePoolKind::ManualRewards => PendingOperationKey::JoiningManualRewards {

2974

                        candidate: op.candidate.clone(),

2975

                        at: 0,

2976

},

2977

};

2978

2979

9

                assert_ok!(PooledStaking::execute_pending_operations(

2980

9

                    origin_of(op.delegator.clone()),

2981

9

                    vec![PendingOperationQuery {

2982

9

                        delegator: op.delegator.clone(),

2983

9

                        operation,

2984

9

}]

2985

9

));

2986

2987

2988

9

f()

2989

9

});

2990

9

2991

2992

#[test]

2993

1

fn test_staking_leave_exact_amount() {

2994

1

    setup_staking_join_and_execute(

2995

1

        vec![A {

2996

1

            delegator: ALICE.into(),

2997

1

            candidate: ALICE.into(),

2998

1

            target_pool: ActivePoolKind::AutoCompounding,

2999

1

            stake: 10 * MinimumSelfDelegation::get(),

3000

1

}],

3001

1

        || {

3002

1

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

3003

1

            assert_ok!(PooledStaking::request_undelegate(

3004

1

                origin_of(ALICE.into()),

3005

1

                ALICE.into(),

3006

1

                ActivePoolKind::AutoCompounding,

3007

1

                SharesOrStake::Stake(stake),

3008

1

));

3009

3010

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

3011

1

            let eligible_candidates =

3012

1

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

3013

1

            assert_eq!(eligible_candidates, vec![]);

3014

1

},

3015

1

3016

1

3017

3018

#[test]

3019

1

fn test_staking_leave_bad_origin() {

3020

1

    setup_staking_join_and_execute(

3021

1

        vec![A {

3022

1

            delegator: ALICE.into(),

3023

1

            candidate: ALICE.into(),

3024

1

            target_pool: ActivePoolKind::AutoCompounding,

3025

1

            stake: 10 * MinimumSelfDelegation::get(),

3026

1

}],

3027

1

        || {

3028

1

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

3029

1

            assert_noop!(

3030

1

                PooledStaking::request_undelegate(

3031

1

                    root_origin(),

3032

1

                    ALICE.into(),

3033

1

                    ActivePoolKind::AutoCompounding,

3034

1

                    SharesOrStake::Stake(stake),

3035

1

),

3036

1

                BadOrigin

3037

1

);

3038

1

},

3039

1

3040

1

3041

3042

#[test]

3043

1

fn test_staking_leave_more_than_allowed() {

3044

1

    setup_staking_join_and_execute(

3045

1

        vec![A {

3046

1

            delegator: ALICE.into(),

3047

1

            candidate: ALICE.into(),

3048

1

            target_pool: ActivePoolKind::AutoCompounding,

3049

1

            stake: 10 * MinimumSelfDelegation::get(),

3050

1

}],

3051

1

        || {

3052

1

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

3053

1

            assert_noop!(

3054

1

                PooledStaking::request_undelegate(

3055

1

                    origin_of(ALICE.into()),

3056

1

                    ALICE.into(),

3057

1

                    ActivePoolKind::AutoCompounding,

3058

1

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

3059

1

),

3060

1

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

3061

1

);

3062

1

},

3063

1

);

3064

1

3065

3066

#[test]

3067

1

fn test_staking_leave_in_separate_transactions() {

3068

1

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

3069

1

3070

1

    setup_staking_join_and_execute(

3071

1

        vec![A {

3072

1

            delegator: ALICE.into(),

3073

1

            candidate: ALICE.into(),

3074

1

            target_pool: ActivePoolKind::AutoCompounding,

3075

1

            stake,

3076

1

}],

3077

1

        || {

3078

1

            let half_stake = stake / 2;

3079

1

            assert_ok!(PooledStaking::request_undelegate(

3080

1

                origin_of(ALICE.into()),

3081

1

                ALICE.into(),

3082

1

                ActivePoolKind::AutoCompounding,

3083

1

                SharesOrStake::Stake(half_stake),

3084

1

));

3085

3086

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

3087

1

            let eligible_candidates =

3088

1

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

3089

1

            let remaining_stake = stake - half_stake;

3090

1

            assert_eq!(

3091

1

                eligible_candidates,

3092

1

                vec![EligibleCandidate {

3093

1

                    candidate: ALICE.into(),

3094

1

                    stake: remaining_stake,

3095

1

}],

3096

1

);

3097

3098

1

            assert_ok!(PooledStaking::request_undelegate(

3099

1

                origin_of(ALICE.into()),

3100

1

                ALICE.into(),

3101

1

                ActivePoolKind::AutoCompounding,

3102

1

                SharesOrStake::Stake(remaining_stake),

3103

1

));

3104

3105

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

3106

1

            let eligible_candidates =

3107

1

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

3108

1

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

3109

1

},

3110

1

);

3111

1

3112

3113

#[test]

3114

1

fn test_staking_leave_all_except_some_dust() {

3115

1

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

3116

1

3117

1

    setup_staking_join_and_execute(

3118

1

        vec![A {

3119

1

            delegator: ALICE.into(),

3120

1

            candidate: ALICE.into(),

3121

1

            target_pool: ActivePoolKind::AutoCompounding,

3122

1

            stake,

3123

1

}],

3124

1

        || {

3125

1

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

3126

1

            assert_ok!(PooledStaking::request_undelegate(

3127

1

                origin_of(ALICE.into()),

3128

1

                ALICE.into(),

3129

1

                ActivePoolKind::AutoCompounding,

3130

1

                SharesOrStake::Stake(stake - dust),

3131

1

));

3132

3133

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

3134

1

            assert_eq!(

3135

1

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

3136

1

                    AccountId::from(ALICE),

3137

1

                    PoolsKey::CandidateTotalStake

3138

1

),

3139

1

                dust,

3140

1

);

3141

3142

1

            let eligible_candidates =

3143

1

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

3144

1

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

3145

3146

            // Leave with remaining stake

3147

1

            assert_ok!(PooledStaking::request_undelegate(

3148

1

                origin_of(ALICE.into()),

3149

1

                ALICE.into(),

3150

1

                ActivePoolKind::AutoCompounding,

3151

1

                SharesOrStake::Stake(dust),

3152

1

));

3153

3154

            // Alice has no more stake left

3155

1

            assert_eq!(

3156

1

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

3157

1

                    AccountId::from(ALICE),

3158

1

                    PoolsKey::CandidateTotalStake

3159

1

),

3160

1

0,

3161

1

);

3162

1

},

3163

1

);

3164

1

3165

3166

#[test]

3167

1

fn test_staking_leave_execute_before_time() {

3168

1

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

3169

1

3170

1

    setup_staking_join_and_execute(

3171

1

        vec![A {

3172

1

            delegator: ALICE.into(),

3173

1

            candidate: ALICE.into(),

3174

1

            target_pool: ActivePoolKind::AutoCompounding,

3175

1

            stake,

3176

1

}],

3177

1

        || {

3178

1

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

3179

1

            let at = Session::current_index();

3180

1

            assert_ok!(PooledStaking::request_undelegate(

3181

1

                origin_of(ALICE.into()),

3182

1

                ALICE.into(),

3183

1

                ActivePoolKind::AutoCompounding,

3184

1

                SharesOrStake::Stake(stake),

3185

1

));

3186

3187

            // Request undelegate does not change account balance

3188

1

            assert_eq!(

3189

1

                balance_before,

3190

1

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

3191

1

);

3192

3193

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

3194

1

            let start_of_session_4 = session_to_block(4);

3195

1

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

3196

1

            run_to_block(start_of_session_4 - 2);

3197

1

3198

1

            assert_noop!(

3199

1

                PooledStaking::execute_pending_operations(

3200

1

                    origin_of(ALICE.into()),

3201

1

                    vec![PendingOperationQuery {

3202

1

                        delegator: ALICE.into(),

3203

1

                        operation: PendingOperationKey::Leaving {

3204

1

                            candidate: ALICE.into(),

3205

1

at,

3206

1

3207

1

}]

3208

1

),

3209

1

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

3210

1

);

3211

1

},

3212

1

);

3213

1

3214

3215

#[test]

3216

1

fn test_staking_leave_execute_any_origin() {

3217

1

    let stake = 10 * MinimumSelfDelegation::get();

3218

1

3219

1

    setup_staking_join_and_execute(

3220

1

        vec![A {

3221

1

            delegator: ALICE.into(),

3222

1

            candidate: ALICE.into(),

3223

1

            target_pool: ActivePoolKind::AutoCompounding,

3224

1

            stake,

3225

1

}],

3226

1

        || {

3227

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

3228

1

            let at = Session::current_index();

3229

1

            assert_ok!(PooledStaking::request_undelegate(

3230

1

                origin_of(ALICE.into()),

3231

1

                ALICE.into(),

3232

1

                ActivePoolKind::AutoCompounding,

3233

1

                SharesOrStake::Stake(stake),

3234

1

));

3235

3236

            // Request undelegate does not change account balance

3237

1

            assert_eq!(

3238

1

                balance_before,

3239

1

                System::account(AccountId::from(ALICE)).data.free

3240

1

);

3241

3242

1

            run_to_session(4);

3243

1

3244

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

3245

1

3246

1

            assert_ok!(PooledStaking::execute_pending_operations(

3247

1

                // Any signed origin can execute this, the stake will go to Alice account

3248

1

                origin_of(BOB.into()),

3249

1

                vec![PendingOperationQuery {

3250

1

                    delegator: ALICE.into(),

3251

1

                    operation: PendingOperationKey::Leaving {

3252

1

                        candidate: ALICE.into(),

3253

1

at,

3254

1

3255

1

}]

3256

1

            ),);

3257

3258

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

3259

1

            assert_eq!(balance_after - balance_before, stake);

3260

1

},

3261

1

);

3262

1

3263

3264

#[test]

3265

1

fn test_staking_leave_execute_bad_origin() {

3266

1

    let stake = 10 * MinimumSelfDelegation::get();

3267

1

3268

1

    setup_staking_join_and_execute(

3269

1

        vec![A {

3270

1

            delegator: ALICE.into(),

3271

1

            candidate: ALICE.into(),

3272

1

            target_pool: ActivePoolKind::AutoCompounding,

3273

1

            stake,

3274

1

}],

3275

1

        || {

3276

1

            let at = Session::current_index();

3277

1

            assert_ok!(PooledStaking::request_undelegate(

3278

1

                origin_of(ALICE.into()),

3279

1

                ALICE.into(),

3280

1

                ActivePoolKind::AutoCompounding,

3281

1

                SharesOrStake::Stake(stake),

3282

1

));

3283

3284

1

            run_to_session(4);

3285

1

3286

1

            assert_noop!(

3287

1

                PooledStaking::execute_pending_operations(

3288

1

                    root_origin(),

3289

1

                    vec![PendingOperationQuery {

3290

1

                        delegator: ALICE.into(),

3291

1

                        operation: PendingOperationKey::Leaving {

3292

1

                            candidate: ALICE.into(),

3293

1

at,

3294

1

3295

1

}]

3296

1

),

3297

1

                BadOrigin

3298

1

);

3299

1

},

3300

1

);

3301

1

3302

3303

#[test]

3304

1

fn test_staking_swap() {

3305

1

    setup_staking_join_and_execute(

3306

1

        vec![A {

3307

1

            delegator: ALICE.into(),

3308

1

            candidate: ALICE.into(),

3309

1

            target_pool: ActivePoolKind::AutoCompounding,

3310

1

            stake: 10 * MinimumSelfDelegation::get(),

3311

1

}],

3312

1

        || {

3313

1

            let stake = 10 * MinimumSelfDelegation::get();

3314

1

            assert_ok!(PooledStaking::swap_pool(

3315

1

                origin_of(ALICE.into()),

3316

1

                ALICE.into(),

3317

1

                ActivePoolKind::AutoCompounding,

3318

1

                SharesOrStake::Stake(stake),

3319

1

));

3320

3321

1

            assert_eq!(

3322

1

                PooledStaking::computed_stake(

3323

1

                    ALICE.into(),

3324

1

                    ALICE.into(),

3325

1

                    PoolKind::AutoCompounding

3326

1

),

3327

1

                Some(0u32.into())

3328

1

);

3329

1

            assert_eq!(

3330

1

                PooledStaking::computed_stake(ALICE.into(), ALICE.into(), PoolKind::ManualRewards),

3331

1

                Some(stake)

3332

1

);

3333

3334

1

            assert_ok!(PooledStaking::swap_pool(

3335

1

                origin_of(ALICE.into()),

3336

1

                ALICE.into(),

3337

1

                ActivePoolKind::ManualRewards,

3338

1

                SharesOrStake::Stake(stake),

3339

1

));

3340

3341

1

            assert_eq!(

3342

1

                PooledStaking::computed_stake(

3343

1

                    ALICE.into(),

3344

1

                    ALICE.into(),

3345

1

                    PoolKind::AutoCompounding

3346

1

),

3347

1

                Some(stake)

3348

1

);

3349

1

            assert_eq!(

3350

1

                PooledStaking::computed_stake(ALICE.into(), ALICE.into(), PoolKind::ManualRewards),

3351

1

                Some(0u32.into())

3352

1

);

3353

1

},

3354

1

3355

1

3356

3357

#[test]

3358

1

fn test_pallet_session_takes_validators_from_invulnerables_and_staking() {

3359

1

    // Alice, Bob, Charlie are invulnerables

3360

1

    // Alice, Dave are in pallet_staking

3361

1

    // Expected collators are Alice, Bob, Charlie, Dave

3362

1

    ExtBuilder::default()

3363

1

        .with_balances(vec![

3364

1

            // Alice gets 10k extra tokens for her mapping deposit

3365

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

3366

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

3367

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

3368

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

3369

1

])

3370

1

        .with_collators(vec![

3371

1

            (AccountId::from(ALICE), 210_000_000 * UNIT),

3372

1

            (AccountId::from(BOB), 100_000_000 * UNIT),

3373

1

            (AccountId::from(CHARLIE), 100_000_000 * UNIT),

3374

1

])

3375

1

        .with_empty_parachains(vec![1001, 1002])

3376

1

        .build()

3377

1

        .execute_with(|| {

3378

1

            run_to_block(2);

3379

1

3380

1

            let stake = 10 * MinimumSelfDelegation::get();

3381

1

3382

1

            assert_ok!(PooledStaking::request_delegate(

3383

1

                origin_of(ALICE.into()),

3384

1

                ALICE.into(),

3385

1

                ActivePoolKind::AutoCompounding,

3386

1

                stake,

3387

1

));

3388

3389

            // Register Dave in pallet_session (invulnerables are automatically registered)

3390

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3391

1

            assert_ok!(Session::set_keys(

3392

1

                origin_of(DAVE.into()),

3393

1

                crate::SessionKeys {

3394

1

                    nimbus: dave_account_id,

3395

1

},

3396

1

                vec![]

3397

1

));

3398

3399

1

            assert_ok!(PooledStaking::request_delegate(

3400

1

                origin_of(DAVE.into()),

3401

1

                DAVE.into(),

3402

1

                ActivePoolKind::AutoCompounding,

3403

1

                stake,

3404

1

));

3405

3406

1

            let eligible_candidates =

3407

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3408

1

            assert_eq!(

3409

1

                eligible_candidates,

3410

1

                vec![

3411

1

                    EligibleCandidate {

3412

1

                        candidate: ALICE.into(),

3413

1

                        stake

3414

1

},

3415

1

                    EligibleCandidate {

3416

1

                        candidate: DAVE.into(),

3417

1

                        stake

3418

1

},

3419

1

3420

1

);

3421

3422

1

            assert_eq!(

3423

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3424

1

                vec![

3425

1

                    AccountId::from(ALICE),

3426

1

                    AccountId::from(BOB),

3427

1

                    AccountId::from(CHARLIE),

3428

1

3429

1

);

3430

3431

            // Need to trigger new session to update pallet_session

3432

1

            run_to_session(2);

3433

1

3434

1

            assert_eq!(

3435

1

                Session::validators(),

3436

1

                vec![

3437

1

                    AccountId::from(ALICE),

3438

1

                    AccountId::from(BOB),

3439

1

                    AccountId::from(CHARLIE),

3440

1

                    AccountId::from(DAVE),

3441

1

3442

1

);

3443

1

});

3444

1

3445

3446

#[test]

3447

1

fn test_pallet_session_limits_num_validators() {

3448

1

    // Set max_collators = 2, now only the first 2 invulnerables are valid collators

3449

1

    ExtBuilder::default()

3450

1

        .with_balances(vec![

3451

1

            // Alice gets 10k extra tokens for her mapping deposit

3452

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

3453

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

3454

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

3455

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

3456

1

])

3457

1

        .with_collators(vec![

3458

1

            (AccountId::from(ALICE), 210_000_000 * UNIT),

3459

1

            (AccountId::from(BOB), 100_000_000 * UNIT),

3460

1

            (AccountId::from(CHARLIE), 100_000_000 * UNIT),

3461

1

])

3462

1

        .with_empty_parachains(vec![1001, 1002])

3463

1

        .with_config(pallet_configuration::HostConfiguration {

3464

1

            max_collators: 2,

3465

1

            min_orchestrator_collators: 2,

3466

1

            max_orchestrator_collators: 2,

3467

1

            collators_per_container: 2,

3468

1

            full_rotation_period: 24,

3469

1

            ..Default::default()

3470

1

})

3471

1

        .build()

3472

1

        .execute_with(|| {

3473

1

            run_to_block(2);

3474

1

3475

1

            let stake = 10 * MinimumSelfDelegation::get();

3476

1

3477

1

            assert_ok!(PooledStaking::request_delegate(

3478

1

                origin_of(ALICE.into()),

3479

1

                ALICE.into(),

3480

1

                ActivePoolKind::AutoCompounding,

3481

1

                stake,

3482

1

));

3483

3484

            // Register Dave in pallet_session (invulnerables are automatically registered)

3485

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3486

1

            assert_ok!(Session::set_keys(

3487

1

                origin_of(DAVE.into()),

3488

1

                crate::SessionKeys {

3489

1

                    nimbus: dave_account_id,

3490

1

},

3491

1

                vec![]

3492

1

));

3493

3494

1

            assert_ok!(PooledStaking::request_delegate(

3495

1

                origin_of(DAVE.into()),

3496

1

                DAVE.into(),

3497

1

                ActivePoolKind::AutoCompounding,

3498

1

                stake,

3499

1

));

3500

3501

1

            let eligible_candidates =

3502

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3503

1

            assert_eq!(

3504

1

                eligible_candidates,

3505

1

                vec![

3506

1

                    EligibleCandidate {

3507

1

                        candidate: ALICE.into(),

3508

1

                        stake

3509

1

},

3510

1

                    EligibleCandidate {

3511

1

                        candidate: DAVE.into(),

3512

1

                        stake

3513

1

},

3514

1

3515

1

);

3516

3517

1

            assert_eq!(

3518

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3519

1

                vec![

3520

1

                    AccountId::from(ALICE),

3521

1

                    AccountId::from(BOB),

3522

1

                    AccountId::from(CHARLIE),

3523

1

3524

1

);

3525

3526

            // Need to trigger new session to update pallet_session

3527

1

            run_to_session(2);

3528

1

3529

1

            assert_eq!(

3530

1

                Session::validators(),

3531

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3532

1

);

3533

1

});

3534

1

3535

3536

#[test]

3537

1

fn test_pallet_session_limits_num_validators_from_staking() {

3538

1

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

3539

1

    ExtBuilder::default()

3540

1

        .with_balances(vec![

3541

1

            // Alice gets 10k extra tokens for her mapping deposit

3542

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

3543

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

3544

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

3545

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

3546

1

])

3547

1

        .with_collators(vec![(AccountId::from(ALICE), 210_000_000 * UNIT)])

3548

1

        .with_empty_parachains(vec![1001, 1002])

3549

1

        .with_config(pallet_configuration::HostConfiguration {

3550

1

            max_collators: 2,

3551

1

            min_orchestrator_collators: 2,

3552

1

            max_orchestrator_collators: 2,

3553

1

            collators_per_container: 2,

3554

1

            full_rotation_period: 24,

3555

1

            ..Default::default()

3556

1

})

3557

1

        .build()

3558

1

        .execute_with(|| {

3559

1

            run_to_block(2);

3560

1

3561

1

            let stake = 10 * MinimumSelfDelegation::get();

3562

1

3563

1

            // Register accounts in pallet_session (invulnerables are automatically registered)

3564

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3565

1

            assert_ok!(Session::set_keys(

3566

1

                origin_of(BOB.into()),

3567

1

                crate::SessionKeys {

3568

1

                    nimbus: bob_account_id,

3569

1

},

3570

1

                vec![]

3571

1

));

3572

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

3573

1

            assert_ok!(Session::set_keys(

3574

1

                origin_of(CHARLIE.into()),

3575

1

                crate::SessionKeys {

3576

1

                    nimbus: charlie_account_id,

3577

1

},

3578

1

                vec![]

3579

1

));

3580

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3581

1

            assert_ok!(Session::set_keys(

3582

1

                origin_of(DAVE.into()),

3583

1

                crate::SessionKeys {

3584

1

                    nimbus: dave_account_id,

3585

1

},

3586

1

                vec![]

3587

1

));

3588

3589

1

            assert_ok!(PooledStaking::request_delegate(

3590

1

                origin_of(BOB.into()),

3591

1

                BOB.into(),

3592

1

                ActivePoolKind::AutoCompounding,

3593

1

                stake,

3594

1

));

3595

3596

1

            assert_ok!(PooledStaking::request_delegate(

3597

1

                origin_of(CHARLIE.into()),

3598

1

                CHARLIE.into(),

3599

1

                ActivePoolKind::AutoCompounding,

3600

1

                stake,

3601

1

));

3602

3603

1

            assert_ok!(PooledStaking::request_delegate(

3604

1

                origin_of(DAVE.into()),

3605

1

                DAVE.into(),

3606

1

                ActivePoolKind::AutoCompounding,

3607

1

                stake,

3608

1

));

3609

3610

1

            let eligible_candidates =

3611

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3612

1

            assert_eq!(

3613

1

                eligible_candidates,

3614

1

                vec![

3615

1

                    EligibleCandidate {

3616

1

                        candidate: BOB.into(),

3617

1

                        stake

3618

1

},

3619

1

                    EligibleCandidate {

3620

1

                        candidate: CHARLIE.into(),

3621

1

                        stake

3622

1

},

3623

1

                    EligibleCandidate {

3624

1

                        candidate: DAVE.into(),

3625

1

                        stake

3626

1

},

3627

1

3628

1

);

3629

3630

1

            assert_eq!(

3631

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3632

1

                vec![AccountId::from(ALICE),]

3633

1

);

3634

3635

            // Need to trigger new session to update pallet_session

3636

1

            run_to_session(2);

3637

1

3638

1

            assert_eq!(

3639

1

                Session::validators(),

3640

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3641

1

);

3642

1

});

3643

1

3644

3645

#[test]

3646

1

fn test_reward_to_staking_candidate() {

3647

1

    // Alice, Bob, Charlie are invulnerables

3648

1

    ExtBuilder::default()

3649

1

        .with_balances(vec![

3650

1

            // Alice gets 10k extra tokens for her mapping deposit

3651

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

3652

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

3653

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

3654

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

3655

1

])

3656

1

        .with_collators(vec![(AccountId::from(ALICE), 210_000_000 * UNIT)])

3657

1

        .with_empty_parachains(vec![1001, 1002])

3658

1

        .build()

3659

1

        .execute_with(|| {

3660

1

            run_to_block(2);

3661

1

3662

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3663

1

            assert_ok!(Session::set_keys(

3664

1

                origin_of(DAVE.into()),

3665

1

                crate::SessionKeys {

3666

1

                    nimbus: dave_account_id,

3667

1

},

3668

1

                vec![]

3669

1

));

3670

3671

            // We make delegations to DAVE so that she is an elligible candidate.

3672

3673

1

            let stake = 10 * MinimumSelfDelegation::get();

3674

1

3675

1

            assert_ok!(PooledStaking::request_delegate(

3676

1

                origin_of(DAVE.into()),

3677

1

                DAVE.into(),

3678

1

                ActivePoolKind::ManualRewards,

3679

1

                stake,

3680

1

));

3681

1

            assert_ok!(PooledStaking::request_delegate(

3682

1

                origin_of(BOB.into()),

3683

1

                DAVE.into(),

3684

1

                ActivePoolKind::AutoCompounding,

3685

1

                stake,

3686

1

));

3687

3688

            // wait few sessions for the request to be executable

3689

1

            run_to_session(3u32);

3690

1

            assert_ok!(PooledStaking::execute_pending_operations(

3691

1

                origin_of(ALICE.into()),

3692

1

                vec![

3693

1

                    PendingOperationQuery {

3694

1

                        delegator: DAVE.into(),

3695

1

                        operation: PendingOperationKey::JoiningManualRewards {

3696

1

                            candidate: DAVE.into(),

3697

1

                            at: 0

3698

1

3699

1

},

3700

1

                    PendingOperationQuery {

3701

1

                        delegator: BOB.into(),

3702

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3703

1

                            candidate: DAVE.into(),

3704

1

                            at: 0

3705

1

3706

1

3707

1

3708

1

));

3709

3710

            // wait for next session so that DAVE is elected

3711

1

            run_to_session(4u32);

3712

1

3713

1

            assert_eq!(

3714

1

                Session::validators(),

3715

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

3716

1

);

3717

3718

1

            let account: AccountId = DAVE.into();

3719

1

            let balance_before = System::account(account.clone()).data.free;

3720

1

            let summary = (0..100)

3721

1

                .find_map(|_| {

3722

1

                    let summary = run_block();

3723

1

                    if summary.author_id == DAVE.into() {

3724

1

                        Some(summary)

3725

                    } else {

3726

                        None

3727

3728

1

})

3729

1

                .unwrap_or_else(|| panic!("DAVE doesn't seem to author any blocks"));

3730

1

            let balance_after = System::account(account).data.free;

3731

1

3732

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3733

1

            // rewards are shared between orchestrator and registered paras

3734

1

            let orchestrator_rewards = all_rewards / 3;

3735

1

            let candidate_rewards = RewardsCollatorCommission::get() * orchestrator_rewards;

3736

1

3737

1

            assert_eq!(

3738

1

                candidate_rewards,

3739

1

                balance_after - balance_before,

3740

                "dave should get the correct reward portion"

3741

);

3742

1

});

3743

1

3744

3745

#[test]

3746

1

fn test_reward_to_invulnerable() {

3747

1

    // Alice, Bob, Charlie are invulnerables

3748

1

    ExtBuilder::default()

3749

1

        .with_balances(vec![

3750

1

            // Alice gets 10k extra tokens for her mapping deposit

3751

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3752

1

            (AccountId::from(BOB), 100_000 * UNIT),

3753

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3754

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3755

1

])

3756

1

        .with_collators(vec![

3757

1

            (AccountId::from(ALICE), 210 * UNIT),

3758

1

            (AccountId::from(BOB), 100 * UNIT),

3759

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3760

1

])

3761

1

        .with_empty_parachains(vec![1001, 1002])

3762

1

        .build()

3763

1

        .execute_with(|| {

3764

1

            run_to_block(2);

3765

1

3766

1

            // We make delegations to ALICE so that she is an elligible candidate.

3767

1

            // However since she is an invulnerable she should get all the

3768

1

            // rewards.

3769

1

3770

1

            let stake = 10 * MinimumSelfDelegation::get();

3771

1

3772

1

            assert_ok!(PooledStaking::request_delegate(

3773

1

                origin_of(ALICE.into()),

3774

1

                ALICE.into(),

3775

1

                ActivePoolKind::ManualRewards,

3776

1

                stake,

3777

1

));

3778

1

            assert_ok!(PooledStaking::request_delegate(

3779

1

                origin_of(BOB.into()),

3780

1

                ALICE.into(),

3781

1

                ActivePoolKind::AutoCompounding,

3782

1

                stake,

3783

1

));

3784

3785

            // wait few sessions for the request to be executable

3786

1

            run_to_session(3u32);

3787

1

            assert_ok!(PooledStaking::execute_pending_operations(

3788

1

                origin_of(ALICE.into()),

3789

1

                vec![

3790

1

                    PendingOperationQuery {

3791

1

                        delegator: ALICE.into(),

3792

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3793

1

                            candidate: ALICE.into(),

3794

1

                            at: 0

3795

1

3796

1

},

3797

1

                    PendingOperationQuery {

3798

1

                        delegator: BOB.into(),

3799

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3800

1

                            candidate: ALICE.into(),

3801

1

                            at: 0

3802

1

3803

1

3804

1

3805

1

));

3806

3807

            // wait for next session so that ALICE is elected

3808

1

            run_to_session(4u32);

3809

1

3810

1

            let account: AccountId = ALICE.into();

3811

1

            let balance_before = System::account(account.clone()).data.free;

3812

1

3813

1

            let summary = (0..100)

3814

2

                .find_map(|_| {

3815

2

                    let summary = run_block();

3816

2

                    if summary.author_id == ALICE.into() {

3817

1

                        Some(summary)

3818

                    } else {

3819

1

                        None

3820

3821

2

})

3822

1

                .unwrap_or_else(|| panic!("ALICE doesn't seem to author any blocks"));

3823

1

3824

1

            let balance_after = System::account(account).data.free;

3825

1

3826

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3827

1

            // rewards are shared between orchestrator and registered paras

3828

1

            let orchestrator_rewards = all_rewards / 3;

3829

1

            assert_eq!(

3830

1

                orchestrator_rewards,

3831

1

                balance_after - balance_before,

3832

                "alice should get the correct reward portion"

3833

);

3834

1

});

3835

1

3836

3837

#[test]

3838

1

fn test_reward_to_invulnerable_with_key_change() {

3839

1

    ExtBuilder::default()

3840

1

        .with_balances(vec![

3841

1

            // Alice gets 10k extra tokens for her mapping deposit

3842

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3843

1

            (AccountId::from(BOB), 100_000 * UNIT),

3844

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3845

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3846

1

])

3847

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3848

1

        .with_empty_parachains(vec![1001, 1002])

3849

1

        .build()

3850

1

        .execute_with(|| {

3851

1

            run_to_block(2);

3852

1

3853

1

            run_to_session(2u32);

3854

1

3855

1

            // change key, this should be reflected 2 sessions afterward

3856

1

            let alice_new_key = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3857

1

            assert_ok!(Session::set_keys(

3858

1

                origin_of(ALICE.into()),

3859

1

                crate::SessionKeys {

3860

1

                    nimbus: alice_new_key,

3861

1

},

3862

1

                vec![]

3863

1

));

3864

3865

1

            run_to_session(4u32);

3866

1

3867

1

            let account: AccountId = ALICE.into();

3868

1

            let balance_before = System::account(account.clone()).data.free;

3869

1

3870

1

            let summary = run_block();

3871

1

            assert_eq!(summary.author_id, ALICE.into());

3872

3873

1

            let balance_after = System::account(account).data.free;

3874

1

3875

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3876

1

            // rewards are shared between orchestrator and registered paras

3877

1

            let orchestrator_rewards = all_rewards / 3;

3878

1

            assert_eq!(

3879

1

                orchestrator_rewards,

3880

1

                balance_after - balance_before,

3881

                "alice should get the correct reward portion"

3882

);

3883

1

});

3884

1

3885

3886

#[test]

3887

1

fn test_migration_config_add_full_rotation_mode() {

3888

1

    ExtBuilder::default().build().execute_with(|| {

3889

        const CONFIGURATION_ACTIVE_CONFIG_KEY: &[u8] =

3890

            &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385");

3891

        const CONFIGURATION_PENDING_CONFIGS_KEY: &[u8] =

3892

            &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22d53b4123b2e186e07fb7bad5dda5f55c0");

3893

3894

        // Modify active config

3895

1

        frame_support::storage::unhashed::put_raw(

3896

1

            CONFIGURATION_ACTIVE_CONFIG_KEY,

3897

1

            &HostConfigurationV3 {

3898

1

                max_collators: 5,

3899

1

                min_orchestrator_collators: 2,

3900

1

                max_orchestrator_collators: 1,

3901

1

                collators_per_container: 3,

3902

1

                full_rotation_period: 4,

3903

1

                collators_per_parathread: 2,

3904

1

                parathreads_per_collator: 1,

3905

1

                target_container_chain_fullness: Perbill::from_percent(45),

3906

1

                max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3907

1

3908

1

            .encode(),

3909

1

);

3910

1

        // Modify pending configs

3911

1

        frame_support::storage::unhashed::put_raw(

3912

1

            CONFIGURATION_PENDING_CONFIGS_KEY,

3913

1

            &vec![

3914

1

3915

1

                    1234u32,

3916

1

                    HostConfigurationV3 {

3917

1

                        max_collators: 1,

3918

1

                        min_orchestrator_collators: 4,

3919

1

                        max_orchestrator_collators: 45,

3920

1

                        collators_per_container: 5,

3921

1

                        full_rotation_period: 1,

3922

1

                        collators_per_parathread: 1,

3923

1

                        parathreads_per_collator: 1,

3924

1

                        target_container_chain_fullness: Perbill::from_percent(65),

3925

1

                        max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3926

1

},

3927

1

),

3928

1

3929

1

                    5678u32,

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

            .encode(),

3944

1

);

3945

1

3946

1

        let migration = MigrateConfigurationAddFullRotationMode::<Runtime>(Default::default());

3947

1

        migration.migrate(Default::default());

3948

1

3949

1

        let expected_active = pallet_configuration::HostConfiguration {

3950

1

            max_collators: 5,

3951

1

            min_orchestrator_collators: 2,

3952

1

            max_orchestrator_collators: 1,

3953

1

            collators_per_container: 3,

3954

1

            full_rotation_period: 4,

3955

1

            collators_per_parathread: 2,

3956

1

            parathreads_per_collator: 1,

3957

1

            target_container_chain_fullness: Perbill::from_percent(45),

3958

1

            max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3959

1

            ..Default::default()

3960

1

};

3961

1

        assert_eq!(Configuration::config(), expected_active);

3962

3963

1

        let expected_pending = vec![

3964

1

3965

1

                1234u32,

3966

1

                pallet_configuration::HostConfiguration {

3967

1

                    max_collators: 1,

3968

1

                    min_orchestrator_collators: 4,

3969

1

                    max_orchestrator_collators: 45,

3970

1

                    collators_per_container: 5,

3971

1

                    full_rotation_period: 1,

3972

1

                    collators_per_parathread: 1,

3973

1

                    parathreads_per_collator: 1,

3974

1

                    target_container_chain_fullness: Perbill::from_percent(65),

3975

1

                    max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3976

1

                    ..Default::default()

3977

1

},

3978

1

),

3979

1

3980

1

                5678u32,

3981

1

                pallet_configuration::HostConfiguration {

3982

1

                    max_collators: 1,

3983

1

                    min_orchestrator_collators: 4,

3984

1

                    max_orchestrator_collators: 45,

3985

1

                    collators_per_container: 5,

3986

1

                    full_rotation_period: 1,

3987

1

                    collators_per_parathread: 1,

3988

1

                    parathreads_per_collator: 1,

3989

1

                    target_container_chain_fullness: Perbill::from_percent(65),

3990

1

                    max_parachain_cores_percentage: Some(Perbill::from_percent(75)),

3991

1

                    ..Default::default()

3992

1

},

3993

1

),

3994

1

];

3995

1

        assert_eq!(Configuration::pending_configs(), expected_pending);

3996

1

});

3997

1

3998

3999

#[test]

4000

1

fn test_migration_registrar_pending_verification() {

4001

1

    ExtBuilder::default().build().execute_with(|| {

4002

        const REGISTRAR_PENDING_VERIFICATION_KEY: &[u8] =

4003

            &hex_literal::hex!("3fba98689ebed1138735e0e7a5a790ab57a35de516113188134ad8e43c6d55ec");

4004

4005

        // Modify active config

4006

1

        let para_ids: Vec<ParaId> = vec![2000.into(), 2001.into(), 2002.into(), 3000.into()];

4007

1

        frame_support::storage::unhashed::put(REGISTRAR_PENDING_VERIFICATION_KEY, &para_ids);

4008

1

4009

1

        let migration = RegistrarPendingVerificationValueToMap::<Runtime>(Default::default());

4010

1

        migration.migrate(Default::default());

4011

1

4012

1

        let empty_key =

4013

1

            frame_support::storage::unhashed::get_raw(REGISTRAR_PENDING_VERIFICATION_KEY);

4014

1

        assert_eq!(empty_key, None);

4015

4016

5

        for para_id in para_ids {

4017

4

            let exists_in_map =

4018

4

                pallet_registrar::PendingVerification::<Runtime>::get(para_id).is_some();

4019

4

            assert!(

4020

4

                exists_in_map,

4021

                "After migration, para id {:?} does not exist in storage map",

4022

                para_id

4023

);

4024

4025

1

});

4026

1

4027

4028

#[test]

4029

1

fn test_collator_assignment_gives_priority_to_invulnerables() {

4030

1

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

4031

1

    ExtBuilder::default()

4032

1

        .with_balances(vec![

4033

1

            // Alice gets 10k extra tokens for her mapping deposit

4034

1

            (AccountId::from(ALICE), 210_000_000_000 * UNIT),

4035

1

            (AccountId::from(BOB), 100_000_000_000 * UNIT),

4036

1

            (AccountId::from(CHARLIE), 100_000_000_000 * UNIT),

4037

1

            (AccountId::from(DAVE), 100_000_000_000 * UNIT),

4038

1

])

4039

1

        .with_collators(vec![

4040

1

            (AccountId::from(ALICE), 210_000_000 * UNIT),

4041

1

            (AccountId::from(DAVE), 100_000_000 * UNIT),

4042

1

])

4043

1

        .with_empty_parachains(vec![1001, 1002])

4044

1

        .build()

4045

1

        .execute_with(|| {

4046

1

            run_to_block(2);

4047

1

4048

1

            let stake = 10 * MinimumSelfDelegation::get();

4049

1

4050

1

            // Register accounts in pallet_session (invulnerables are automatically registered)

4051

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4052

1

            assert_ok!(Session::set_keys(

4053

1

                origin_of(BOB.into()),

4054

1

                crate::SessionKeys {

4055

1

                    nimbus: bob_account_id,

4056

1

},

4057

1

                vec![]

4058

1

));

4059

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

4060

1

            assert_ok!(Session::set_keys(

4061

1

                origin_of(CHARLIE.into()),

4062

1

                crate::SessionKeys {

4063

1

                    nimbus: charlie_account_id,

4064

1

},

4065

1

                vec![]

4066

1

));

4067

4068

1

            assert_ok!(PooledStaking::request_delegate(

4069

1

                origin_of(BOB.into()),

4070

1

                BOB.into(),

4071

1

                ActivePoolKind::AutoCompounding,

4072

1

                stake,

4073

1

));

4074

1

            assert_ok!(PooledStaking::request_delegate(

4075

1

                origin_of(CHARLIE.into()),

4076

1

                CHARLIE.into(),

4077

1

                ActivePoolKind::AutoCompounding,

4078

1

                stake,

4079

1

));

4080

4081

1

            let eligible_candidates =

4082

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

4083

1

            assert_eq!(

4084

1

                eligible_candidates,

4085

1

                vec![

4086

1

                    EligibleCandidate {

4087

1

                        candidate: BOB.into(),

4088

1

                        stake

4089

1

},

4090

1

                    EligibleCandidate {

4091

1

                        candidate: CHARLIE.into(),

4092

1

                        stake

4093

1

},

4094

1

4095

1

);

4096

4097

1

            assert_eq!(

4098

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

4099

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

4100

1

);

4101

4102

1

            set_parachain_inherent_data_random_seed([1; 32]);

4103

1

            run_block();

4104

1

4105

1

            // Need to trigger new session to update pallet_session

4106

1

            run_to_session(2);

4107

1

4108

1

            assert_eq!(

4109

1

                Session::validators(),

4110

1

                vec![

4111

1

                    AccountId::from(ALICE),

4112

1

                    AccountId::from(DAVE),

4113

1

                    AccountId::from(BOB),

4114

1

                    AccountId::from(CHARLIE)

4115

1

4116

1

);

4117

4118

            // Need to trigger full rotation to ensure invulnerables are assigned

4119

1

            let rotation_period = Configuration::config().full_rotation_period;

4120

1

            run_to_session(rotation_period);

4121

1

4122

1

            assert!(

4123

1

                CollatorAssignment::collator_container_chain()

4124

1

                    .orchestrator_chain

4125

1

                    .contains(&AccountId::from(ALICE)),

4126

                "CollatorAssignment did not give priority to invulnerable ALICE: {:?}",

4127

                CollatorAssignment::collator_container_chain()

4128

);

4129

4130

1

            assert!(

4131

1

                CollatorAssignment::collator_container_chain()

4132

1

                    .orchestrator_chain

4133

1

                    .contains(&AccountId::from(DAVE)),

4134

                "CollatorAssignment did not give priority to invulnerable DAVE: {:?}",

4135

                CollatorAssignment::collator_container_chain()

4136

);

4137

1

});

4138

1

4139

4140

#[test]

4141

1

fn test_can_buy_credits_before_registering_para() {

4142

1

    ExtBuilder::default()

4143

1

        .with_balances(vec![

4144

1

            // Alice gets 10k extra tokens for her mapping deposit

4145

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4146

1

            (AccountId::from(BOB), 100_000 * UNIT),

4147

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4148

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4149

1

])

4150

1

        .with_collators(vec![

4151

1

            (AccountId::from(ALICE), 210 * UNIT),

4152

1

            (AccountId::from(BOB), 100 * UNIT),

4153

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4154

1

            (AccountId::from(DAVE), 100 * UNIT),

4155

1

])

4156

1

        .build()

4157

1

        .execute_with(|| {

4158

1

            run_to_block(2);

4159

1

4160

1

            // Try to buy the maximum amount of credits

4161

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4162

1

4163

1

            assert_ok!(ServicesPayment::purchase_credits(

4164

1

                origin_of(ALICE.into()),

4165

1

                1001.into(),

4166

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4167

1

));

4168

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4169

1

4170

1

            // Now parachain tank should have this amount

4171

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4172

1

                .data

4173

1

                .free;

4174

1

4175

1

            assert_eq!(

4176

1

                balance_tank,

4177

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4178

1

);

4179

4180

1

            let expected_cost = block_credits_to_required_balance(u32::MAX, 1001.into());

4181

1

            assert_eq!(balance_before - balance_after, expected_cost);

4182

1

});

4183

1

4184

4185

#[test]

4186

1

fn test_cannot_mark_valid_para_with_no_bootnodes() {

4187

1

    ExtBuilder::default()

4188

1

        .with_balances(vec![

4189

1

            // Alice gets 10k extra tokens for her mapping deposit

4190

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4191

1

            (AccountId::from(BOB), 100_000 * UNIT),

4192

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4193

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4194

1

])

4195

1

        .with_collators(vec![

4196

1

            (AccountId::from(ALICE), 210 * UNIT),

4197

1

            (AccountId::from(BOB), 100 * UNIT),

4198

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4199

1

            (AccountId::from(DAVE), 100 * UNIT),

4200

1

])

4201

1

        .build()

4202

1

        .execute_with(|| {

4203

1

            run_to_block(2);

4204

1

            assert_ok!(Registrar::register(

4205

1

                origin_of(ALICE.into()),

4206

1

                1001.into(),

4207

1

                empty_genesis_data(),

4208

1

                None

4209

1

));

4210

1

            assert_noop!(

4211

1

                Registrar::mark_valid_for_collating(root_origin(), 1001.into()),

4212

1

                pallet_data_preservers::Error::<Runtime>::NoBootNodes,

4213

1

);

4214

1

});

4215

1

4216

4217

#[test]

4218

1

fn test_can_buy_credits_before_registering_para_and_receive_free_credits() {

4219

1

    ExtBuilder::default()

4220

1

        .with_balances(vec![

4221

1

            // Alice gets 10k extra tokens for her mapping deposit

4222

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4223

1

            (AccountId::from(BOB), 100_000 * UNIT),

4224

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4225

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4226

1

])

4227

1

        .with_collators(vec![

4228

1

            (AccountId::from(ALICE), 210 * UNIT),

4229

1

            (AccountId::from(BOB), 100 * UNIT),

4230

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4231

1

            (AccountId::from(DAVE), 100 * UNIT),

4232

1

])

4233

1

        .build()

4234

1

        .execute_with(|| {

4235

1

            run_to_block(2);

4236

1

4237

1

            // Try to buy (MaxCreditsStored - 1) credits

4238

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4239

1

            assert_ok!(ServicesPayment::purchase_credits(

4240

1

                origin_of(ALICE.into()),

4241

1

                1001.into(),

4242

1

                block_credits_to_required_balance(

4243

1

                    crate::FreeBlockProductionCredits::get() - 1,

4244

1

                    1001.into()

4245

1

4246

1

));

4247

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4248

1

4249

1

            // Now parachain tank should have this amount

4250

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4251

1

                .data

4252

1

                .free;

4253

1

4254

1

            assert_eq!(

4255

1

                balance_tank,

4256

1

                block_credits_to_required_balance(

4257

1

                    crate::FreeBlockProductionCredits::get() - 1,

4258

1

                    1001.into()

4259

1

4260

1

);

4261

4262

1

            let expected_cost = block_credits_to_required_balance(

4263

1

                crate::FreeBlockProductionCredits::get() - 1,

4264

1

                1001.into(),

4265

1

);

4266

1

            assert_eq!(balance_before - balance_after, expected_cost);

4267

4268

            // Now register para

4269

1

            assert_ok!(Registrar::register(

4270

1

                origin_of(ALICE.into()),

4271

1

                1001.into(),

4272

1

                empty_genesis_data(),

4273

1

                None

4274

1

));

4275

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4276

1

            assert_ok!(Registrar::mark_valid_for_collating(

4277

1

                root_origin(),

4278

1

                1001.into()

4279

1

));

4280

4281

            // We received aññ free credits, because we cannot have more than MaxCreditsStored

4282

1

            let credits =

4283

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4284

1

                    .unwrap_or_default();

4285

1

            assert_eq!(credits, crate::FreeBlockProductionCredits::get());

4286

1

});

4287

1

4288

4289

#[test]

4290

1

fn test_deregister_and_register_again_does_not_give_free_credits() {

4291

1

    ExtBuilder::default()

4292

1

        .with_balances(vec![

4293

1

            // Alice gets 10k extra tokens for her mapping deposit

4294

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4295

1

            (AccountId::from(BOB), 100_000 * UNIT),

4296

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4297

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4298

1

])

4299

1

        .with_collators(vec![

4300

1

            (AccountId::from(ALICE), 210 * UNIT),

4301

1

            (AccountId::from(BOB), 100 * UNIT),

4302

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4303

1

            (AccountId::from(DAVE), 100 * UNIT),

4304

1

])

4305

1

        .build()

4306

1

        .execute_with(|| {

4307

1

            run_to_block(2);

4308

1

4309

1

            // Register

4310

1

            assert_ok!(Registrar::register(

4311

1

                origin_of(ALICE.into()),

4312

1

                1001.into(),

4313

1

                empty_genesis_data(),

4314

1

                None

4315

1

            ),);

4316

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4317

1

            assert_ok!(Registrar::mark_valid_for_collating(

4318

1

                root_origin(),

4319

1

                1001.into()

4320

1

            ),);

4321

            // We received free credits

4322

1

            let credits =

4323

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4324

1

                    .unwrap_or_default();

4325

1

            assert_eq!(credits, crate::FreeBlockProductionCredits::get());

4326

            // Deregister after 1 session

4327

1

            run_to_session(1);

4328

1

            assert_ok!(Registrar::deregister(root_origin(), 1001.into()), ());

4329

4330

1

            run_to_session(3);

4331

1

            let credits_before_2nd_register =

4332

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4333

1

                    .unwrap_or_default();

4334

1

            // We spent some credits because this container chain had collators for 1 session

4335

1

            assert_ne!(

4336

1

                credits_before_2nd_register,

4337

1

                crate::FreeBlockProductionCredits::get()

4338

1

);

4339

            // Register again

4340

1

            assert_ok!(Registrar::register(

4341

1

                origin_of(ALICE.into()),

4342

1

                1001.into(),

4343

1

                empty_genesis_data(),

4344

1

                None

4345

1

            ),);

4346

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4347

1

            assert_ok!(Registrar::mark_valid_for_collating(

4348

1

                root_origin(),

4349

1

                1001.into()

4350

1

            ),);

4351

            // No more free credits

4352

1

            let credits =

4353

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4354

1

                    .unwrap_or_default();

4355

1

            assert_eq!(credits, credits_before_2nd_register);

4356

1

});

4357

1

4358

4359

#[test]

4360

1

fn test_sudo_can_register_foreign_assets_and_manager_change_paremeters() {

4361

1

    ExtBuilder::default()

4362

1

        .with_balances(vec![

4363

1

            // Alice gets 10k extra tokens for her mapping deposit

4364

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4365

1

            (AccountId::from(BOB), 100_000 * UNIT),

4366

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4367

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4368

1

])

4369

1

        .with_collators(vec![

4370

1

            (AccountId::from(ALICE), 210 * UNIT),

4371

1

            (AccountId::from(BOB), 100 * UNIT),

4372

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4373

1

            (AccountId::from(DAVE), 100 * UNIT),

4374

1

])

4375

1

4376

1

        .build()

4377

1

        .execute_with(|| {

4378

1

4379

1

            // We register the asset with Alice as manager

4380

1

            assert_ok!(ForeignAssetsCreator::create_foreign_asset(root_origin(), Location::parent(), 1, AccountId::from(ALICE), true, 1), ());

4381

1

            assert_eq!(ForeignAssetsCreator::foreign_asset_for_id(1), Some(Location::parent()));

4382

1

            assert_eq!(ForeignAssetsCreator::asset_id_for_foreign(Location::parent()), Some(1));

4383

4384

            // Alice now can change parameters like metadata from the asset

4385

1

            assert_ok!(ForeignAssets::set_metadata(origin_of(ALICE.into()), 1, b"xcDot".to_vec(), b"xcDot".to_vec(), 12));

4386

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::name(1),  b"xcDot".to_vec());

4387

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::symbol(1),  b"xcDot".to_vec());

4388

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::decimals(1),  12);

4389

4390

            // Any other person cannot do this

4391

1

            assert_noop!(

4392

1

                ForeignAssets::set_metadata(origin_of(BOB.into()), 1, b"dummy".to_vec(), b"dummy".to_vec(), 12),

4393

1

                pallet_assets::Error::<Runtime, Instance1>::NoPermission

4394

1

);

4395

4396

            // Alice now can mint

4397

1

            assert_ok!(ForeignAssets::mint(origin_of(ALICE.into()), 1, AccountId::from(BOB).into(), 1000));

4398

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::total_issuance(1),  1000);

4399

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::balance(1, &AccountId::from(BOB)),  1000);

4400

1

});

4401

1

4402

4403

#[test]

4404

1

fn test_assets_cannot_be_created_from_signed_origins() {

4405

1

    ExtBuilder::default()

4406

1

        .with_balances(vec![

4407

1

            // Alice gets 10k extra tokens for her mapping deposit

4408

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4409

1

            (AccountId::from(BOB), 100_000 * UNIT),

4410

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4411

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4412

1

])

4413

1

        .with_collators(vec![

4414

1

            (AccountId::from(ALICE), 210 * UNIT),

4415

1

            (AccountId::from(BOB), 100 * UNIT),

4416

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4417

1

            (AccountId::from(DAVE), 100 * UNIT),

4418

1

])

4419

1

        .build()

4420

1

        .execute_with(|| {

4421

1

            // We try to register the asset with Alice as origin

4422

1

            // Any other person cannot do this

4423

1

            assert_noop!(

4424

1

                ForeignAssetsCreator::create_foreign_asset(

4425

1

                    origin_of(ALICE.into()),

4426

1

                    Location::parent(),

4427

1

1,

4428

1

                    AccountId::from(ALICE),

4429

1

                    true,

4430

1

4431

1

),

4432

1

                BadOrigin

4433

1

);

4434

4435

1

            assert_noop!(

4436

1

                ForeignAssets::create(origin_of(ALICE.into()), 1, AccountId::from(ALICE).into(), 1),

4437

1

                BadOrigin

4438

1

);

4439

1

});

4440

1

4441

4442

#[test]

4443

1

fn test_asset_rate_can_be_set_from_sudo_but_not_from_signed() {

4444

1

    ExtBuilder::default()

4445

1

        .with_balances(vec![

4446

1

            // Alice gets 10k extra tokens for her mapping deposit

4447

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4448

1

            (AccountId::from(BOB), 100_000 * UNIT),

4449

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4450

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4451

1

])

4452

1

        .with_collators(vec![

4453

1

            (AccountId::from(ALICE), 210 * UNIT),

4454

1

            (AccountId::from(BOB), 100 * UNIT),

4455

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4456

1

            (AccountId::from(DAVE), 100 * UNIT),

4457

1

])

4458

1

        .build()

4459

1

        .execute_with(|| {

4460

1

            // We try to set the rate from non-sudo

4461

1

            assert_noop!(

4462

1

                AssetRate::create(origin_of(ALICE.into()), Box::new(1), FixedU128::from_u32(1)),

4463

1

                BadOrigin

4464

1

);

4465

4466

            // We try to set the rate from sudo

4467

1

            assert_ok!(AssetRate::create(

4468

1

                root_origin(),

4469

1

                Box::new(1),

4470

1

                FixedU128::from_u32(1)

4471

1

));

4472

4473

1

            assert_eq!(

4474

1

                pallet_asset_rate::ConversionRateToNative::<Runtime>::get(1),

4475

1

                Some(FixedU128::from_u32(1))

4476

1

);

4477

1

});

4478

1

4479

4480

#[test]

4481

1

fn test_division_by_0() {

4482

1

    ExtBuilder::default()

4483

1

        .with_balances(vec![

4484

1

            // Alice gets 10k extra tokens for her mapping deposit

4485

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4486

1

            (AccountId::from(BOB), 100_000 * UNIT),

4487

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4488

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4489

1

])

4490

1

        .with_collators(vec![

4491

1

            (AccountId::from(ALICE), 210 * UNIT),

4492

1

            (AccountId::from(BOB), 100 * UNIT),

4493

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4494

1

            (AccountId::from(DAVE), 100 * UNIT),

4495

1

])

4496

1

        .build()

4497

1

        .execute_with(|| {

4498

1

            // We try to set 0 rate to make sure we dont overflow

4499

1

            assert_ok!(AssetRate::create(

4500

1

                root_origin(),

4501

1

                Box::new(1),

4502

1

                FixedU128::from_u32(0)

4503

1

));

4504

4505

            use frame_support::traits::tokens::ConversionToAssetBalance;

4506

1

            let balance = AssetRate::to_asset_balance(1, 1);

4507

1

            assert!(balance.is_err());

4508

1

});

4509

1

4510

4511

#[test]

4512

1

fn test_register_parathread() {

4513

1

    ExtBuilder::default()

4514

1

        .with_balances(vec![

4515

1

            // Alice gets 10k extra tokens for her mapping deposit

4516

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4517

1

            (AccountId::from(BOB), 100_000 * UNIT),

4518

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4519

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4520

1

])

4521

1

        .with_collators(vec![

4522

1

            (AccountId::from(ALICE), 210 * UNIT),

4523

1

            (AccountId::from(BOB), 100 * UNIT),

4524

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4525

1

            (AccountId::from(DAVE), 100 * UNIT),

4526

1

])

4527

1

        .build()

4528

1

        .execute_with(|| {

4529

1

            run_to_block(2);

4530

1

4531

1

            // Register

4532

1

            assert_ok!(Registrar::register_parathread(

4533

1

                origin_of(ALICE.into()),

4534

1

                3001.into(),

4535

1

                SlotFrequency { min: 1, max: 1 },

4536

1

                empty_genesis_data(),

4537

1

                None

4538

1

));

4539

1

            set_dummy_boot_node(origin_of(ALICE.into()), 3001.into());

4540

1

            assert_ok!(Registrar::mark_valid_for_collating(

4541

1

                root_origin(),

4542

1

                3001.into()

4543

1

));

4544

4545

1

            run_to_session(2);

4546

1

            let assignment = CollatorAssignment::collator_container_chain();

4547

1

            assert_eq!(

4548

1

                assignment.container_chains[&ParaId::from(3001)],

4549

1

                vec![CHARLIE.into()]

4550

1

);

4551

1

});

4552

1

4553

4554

#[test]

4555

1

fn test_register_parathread_genesis() {

4556

1

    let parathread_params = tp_traits::ParathreadParams {

4557

1

        slot_frequency: SlotFrequency { min: 1, max: 1 },

4558

1

};

4559

1

    ExtBuilder::default()

4560

1

        .with_balances(vec![

4561

1

            // Alice gets 10k extra tokens for her mapping deposit

4562

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4563

1

            (AccountId::from(BOB), 100_000 * UNIT),

4564

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4565

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4566

1

])

4567

1

        .with_collators(vec![

4568

1

            (AccountId::from(ALICE), 210 * UNIT),

4569

1

            (AccountId::from(BOB), 100 * UNIT),

4570

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4571

1

            (AccountId::from(DAVE), 100 * UNIT),

4572

1

])

4573

1

        .with_para_ids(vec![ParaRegistrationParams {

4574

1

            para_id: 3001,

4575

1

            genesis_data: empty_genesis_data(),

4576

1

            block_production_credits: u32::MAX,

4577

1

            collator_assignment_credits: u32::MAX,

4578

1

            parathread_params: Some(parathread_params.clone()),

4579

1

}])

4580

1

        .build()

4581

1

        .execute_with(|| {

4582

1

            run_to_block(2);

4583

1

4584

1

            assert_eq!(Registrar::registered_para_ids(), vec![3001.into()]);

4585

1

            assert_eq!(

4586

1

                pallet_registrar::ParathreadParams::<Runtime>::get(ParaId::from(3001)),

4587

1

                Some(parathread_params)

4588

1

);

4589

4590

1

            let assignment = CollatorAssignment::collator_container_chain();

4591

1

            assert_eq!(

4592

1

                assignment.container_chains[&ParaId::from(3001)],

4593

1

                vec![CHARLIE.into()]

4594

1

);

4595

1

});

4596

1

4597

4598

#[test]

4599

1

fn test_ed_plus_block_credit_session_purchase_works() {

4600

1

    ExtBuilder::default()

4601

1

        .with_balances(vec![

4602

1

            // Alice gets 10k extra tokens for her mapping deposit

4603

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4604

1

            (AccountId::from(BOB), 100_000 * UNIT),

4605

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4606

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4607

1

])

4608

1

        .with_collators(vec![

4609

1

            (AccountId::from(ALICE), 210 * UNIT),

4610

1

            (AccountId::from(BOB), 100 * UNIT),

4611

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4612

1

            (AccountId::from(DAVE), 100 * UNIT),

4613

1

])

4614

1

        .build()

4615

1

        .execute_with(|| {

4616

1

            run_to_block(2);

4617

1

            // Assert current slot gets updated

4618

1

            assert_eq!(current_slot(), 1u64);

4619

1

            assert!(current_author() == AccountId::from(BOB));

4620

4621

            // Alice and Bob collate in our chain

4622

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4623

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4624

1

4625

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4626

4627

1

            assert_ok!(Registrar::register(

4628

1

                origin_of(ALICE.into()),

4629

1

                1001.into(),

4630

1

                empty_genesis_data(),

4631

1

                None

4632

1

));

4633

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4634

1

            assert_ok!(Registrar::mark_valid_for_collating(

4635

1

                root_origin(),

4636

1

                1001.into()

4637

1

));

4638

            // Need to reset credits to 0 because now parachains are given free credits on register

4639

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4640

1

                root_origin(),

4641

1

                1001.into(),

4642

1

4643

1

));

4644

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

4645

1

                + crate::EXISTENTIAL_DEPOSIT;

4646

1

4647

1

            // Fill the tank

4648

1

            assert_ok!(ServicesPayment::purchase_credits(

4649

1

                origin_of(ALICE.into()),

4650

1

                1001.into(),

4651

1

                credits_1001

4652

1

));

4653

4654

            // Assignment should happen after 2 sessions

4655

1

            run_to_session(1u32);

4656

1

            let assignment = CollatorAssignment::collator_container_chain();

4657

1

            assert!(assignment.container_chains.is_empty());

4658

1

            run_to_session(2u32);

4659

1

            // Charlie and Dave should be assigned to para 1001

4660

1

            let assignment = CollatorAssignment::collator_container_chain();

4661

1

            assert_eq!(

4662

1

                assignment.container_chains[&1001u32.into()],

4663

1

                vec![CHARLIE.into(), DAVE.into()]

4664

1

);

4665

4666

            // Simulate block inclusion from container chain 1001

4667

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4668

1

            let slot: u64 = 5;

4669

1

            let s = ParaHeaderSproofBuilderItem {

4670

1

                para_id: 1001.into(),

4671

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4672

1

                    parent_hash: Default::default(),

4673

1

                    number: 1,

4674

1

                    state_root: Default::default(),

4675

1

                    extrinsics_root: Default::default(),

4676

1

                    digest: sp_runtime::generic::Digest {

4677

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4678

1

},

4679

1

}),

4680

1

};

4681

1

4682

1

            sproof.items.push(s);

4683

1

            set_author_noting_inherent_data(sproof);

4684

1

4685

1

            run_block();

4686

1

4687

1

            // After this it should not be assigned anymore, since credits are not payable

4688

1

            run_to_session(3u32);

4689

1

            // Nobody should be assigned to para 1001

4690

1

            let assignment = CollatorAssignment::collator_container_chain();

4691

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4692

1

});

4693

1

4694

4695

#[test]

4696

1

fn test_ed_plus_block_credit_session_minus_1_purchase_fails() {

4697

1

    ExtBuilder::default()

4698

1

        .with_balances(vec![

4699

1

            // Alice gets 10k extra tokens for her mapping deposit

4700

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4701

1

            (AccountId::from(BOB), 100_000 * UNIT),

4702

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4703

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4704

1

])

4705

1

        .with_collators(vec![

4706

1

            (AccountId::from(ALICE), 210 * UNIT),

4707

1

            (AccountId::from(BOB), 100 * UNIT),

4708

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4709

1

            (AccountId::from(DAVE), 100 * UNIT),

4710

1

])

4711

1

        .build()

4712

1

        .execute_with(|| {

4713

1

            run_to_block(2);

4714

1

            // Assert current slot gets updated

4715

1

            assert_eq!(current_slot(), 1u64);

4716

1

            assert!(current_author() == AccountId::from(BOB));

4717

4718

            // Alice and Bob collate in our chain

4719

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4720

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4721

1

4722

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4723

4724

1

            assert_ok!(Registrar::register(

4725

1

                origin_of(ALICE.into()),

4726

1

                1001.into(),

4727

1

                empty_genesis_data(),

4728

1

                None

4729

1

));

4730

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4731

1

            assert_ok!(Registrar::mark_valid_for_collating(

4732

1

                root_origin(),

4733

1

                1001.into()

4734

1

));

4735

            // Need to reset credits to 0 because now parachains are given free credits on register

4736

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4737

1

                root_origin(),

4738

1

                1001.into(),

4739

1

4740

1

));

4741

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

4742

1

                + crate::EXISTENTIAL_DEPOSIT

4743

1

                - 1;

4744

1

4745

1

            // Fill the tank

4746

1

            assert_ok!(ServicesPayment::purchase_credits(

4747

1

                origin_of(ALICE.into()),

4748

1

                1001.into(),

4749

1

                credits_1001

4750

1

));

4751

4752

            // Assignment should happen after 2 sessions

4753

1

            run_to_session(1u32);

4754

1

            let assignment = CollatorAssignment::collator_container_chain();

4755

1

            assert!(assignment.container_chains.is_empty());

4756

1

            run_to_session(2u32);

4757

1

            // Charlie and Dave should not be assigned to para 1001

4758

1

            let assignment = CollatorAssignment::collator_container_chain();

4759

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4760

1

});

4761

1

4762

4763

#[test]

4764

1

fn test_reassignment_ed_plus_two_block_credit_session_purchase_works() {

4765

1

    ExtBuilder::default()

4766

1

        .with_balances(vec![

4767

1

            // Alice gets 10k extra tokens for her mapping deposit

4768

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4769

1

            (AccountId::from(BOB), 100_000 * UNIT),

4770

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4771

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4772

1

])

4773

1

        .with_collators(vec![

4774

1

            (AccountId::from(ALICE), 210 * UNIT),

4775

1

            (AccountId::from(BOB), 100 * UNIT),

4776

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4777

1

            (AccountId::from(DAVE), 100 * UNIT),

4778

1

])

4779

1

        .build()

4780

1

        .execute_with(|| {

4781

1

            run_to_block(2);

4782

1

            // Assert current slot gets updated

4783

1

            assert_eq!(current_slot(), 1u64);

4784

1

            assert!(current_author() == AccountId::from(BOB));

4785

4786

            // Alice and Bob collate in our chain

4787

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4788

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4789

1

4790

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4791

4792

1

            assert_ok!(Registrar::register(

4793

1

                origin_of(ALICE.into()),

4794

1

                1001.into(),

4795

1

                empty_genesis_data(),

4796

1

                None

4797

1

));

4798

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4799

1

            assert_ok!(Registrar::mark_valid_for_collating(

4800

1

                root_origin(),

4801

1

                1001.into()

4802

1

));

4803

            // Need to reset credits to 0 because now parachains are given free credits on register

4804

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4805

1

                root_origin(),

4806

1

                1001.into(),

4807

1

4808

1

));

4809

            // On reassignment the blocks credits needed should be enough for the current session and the next one

4810

1

            let credits_1001 =

4811

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into())

4812

1

                    + crate::EXISTENTIAL_DEPOSIT;

4813

1

4814

1

            // Fill the tank

4815

1

            assert_ok!(ServicesPayment::purchase_credits(

4816

1

                origin_of(ALICE.into()),

4817

1

                1001.into(),

4818

1

                credits_1001

4819

1

));

4820

4821

            // Assignment should happen after 2 sessions

4822

1

            run_to_session(1u32);

4823

1

            let assignment = CollatorAssignment::collator_container_chain();

4824

1

            assert!(assignment.container_chains.is_empty());

4825

4826

1

            run_to_session(2u32);

4827

1

            // Charlie and Dave should be assigned to para 1001

4828

1

            let assignment = CollatorAssignment::collator_container_chain();

4829

1

            assert_eq!(

4830

1

                assignment.container_chains[&1001u32.into()],

4831

1

                vec![CHARLIE.into(), DAVE.into()]

4832

1

);

4833

4834

            // Simulate block inclusion from container chain 1001

4835

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4836

1

            let slot: u64 = 5;

4837

1

            let s = ParaHeaderSproofBuilderItem {

4838

1

                para_id: 1001.into(),

4839

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4840

1

                    parent_hash: Default::default(),

4841

1

                    number: 1,

4842

1

                    state_root: Default::default(),

4843

1

                    extrinsics_root: Default::default(),

4844

1

                    digest: sp_runtime::generic::Digest {

4845

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4846

1

},

4847

1

}),

4848

1

};

4849

1

4850

1

            sproof.items.push(s);

4851

1

            set_author_noting_inherent_data(sproof);

4852

1

4853

1

            run_block();

4854

1

4855

1

            // Session 3 should still be assigned

4856

1

            run_to_session(3u32);

4857

1

            // Charlie and Dave should be assigned to para 1001

4858

1

            let assignment = CollatorAssignment::collator_container_chain();

4859

1

            assert_eq!(

4860

1

                assignment.container_chains[&1001u32.into()],

4861

1

                vec![CHARLIE.into(), DAVE.into()]

4862

1

);

4863

4864

            // After this it should not be assigned anymore, since credits are not payable

4865

1

            run_to_session(4u32);

4866

1

            // Nobody should be assigned to para 1001

4867

1

            let assignment = CollatorAssignment::collator_container_chain();

4868

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4869

1

});

4870

1

4871

4872

#[test]

4873

1

fn test_reassignment_ed_plus_two_block_credit_session_minus_1_purchase_fails() {

4874

1

    ExtBuilder::default()

4875

1

        .with_balances(vec![

4876

1

            // Alice gets 10k extra tokens for her mapping deposit

4877

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4878

1

            (AccountId::from(BOB), 100_000 * UNIT),

4879

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4880

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4881

1

])

4882

1

        .with_collators(vec![

4883

1

            (AccountId::from(ALICE), 210 * UNIT),

4884

1

            (AccountId::from(BOB), 100 * UNIT),

4885

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4886

1

            (AccountId::from(DAVE), 100 * UNIT),

4887

1

])

4888

1

        .build()

4889

1

        .execute_with(|| {

4890

1

            run_to_block(2);

4891

1

            // Assert current slot gets updated

4892

1

            assert_eq!(current_slot(), 1u64);

4893

1

            assert!(current_author() == AccountId::from(BOB));

4894

4895

            // Alice and Bob collate in our chain

4896

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4897

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4898

1

4899

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4900

4901

1

            assert_ok!(Registrar::register(

4902

1

                origin_of(ALICE.into()),

4903

1

                1001.into(),

4904

1

                empty_genesis_data(),

4905

1

                None

4906

1

));

4907

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4908

1

            assert_ok!(Registrar::mark_valid_for_collating(

4909

1

                root_origin(),

4910

1

                1001.into()

4911

1

));

4912

            // Need to reset credits to 0 because now parachains are given free credits on register

4913

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4914

1

                root_origin(),

4915

1

                1001.into(),

4916

1

4917

1

));

4918

1

            let credits_1001 =

4919

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into())

4920

1

                    + crate::EXISTENTIAL_DEPOSIT

4921

1

                    - 1;

4922

1

4923

1

            // Fill the tank

4924

1

            assert_ok!(ServicesPayment::purchase_credits(

4925

1

                origin_of(ALICE.into()),

4926

1

                1001.into(),

4927

1

                credits_1001

4928

1

));

4929

4930

            // Assignment should happen after 2 sessions

4931

1

            run_to_session(1u32);

4932

1

            let assignment = CollatorAssignment::collator_container_chain();

4933

1

            assert!(assignment.container_chains.is_empty());

4934

4935

1

            run_to_session(2u32);

4936

1

            // Charlie and Dave should be assigned to para 1001

4937

1

            let assignment = CollatorAssignment::collator_container_chain();

4938

1

            assert_eq!(

4939

1

                assignment.container_chains[&1001u32.into()],

4940

1

                vec![CHARLIE.into(), DAVE.into()]

4941

1

);

4942

4943

            // Simulate block inclusion from container chain 1001

4944

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4945

1

            let slot: u64 = 5;

4946

1

            let s = ParaHeaderSproofBuilderItem {

4947

1

                para_id: 1001.into(),

4948

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4949

1

                    parent_hash: Default::default(),

4950

1

                    number: 1,

4951

1

                    state_root: Default::default(),

4952

1

                    extrinsics_root: Default::default(),

4953

1

                    digest: sp_runtime::generic::Digest {

4954

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4955

1

},

4956

1

}),

4957

1

};

4958

1

4959

1

            sproof.items.push(s);

4960

1

            set_author_noting_inherent_data(sproof);

4961

1

4962

1

            run_block();

4963

1

4964

1

            // After this it should not be assigned anymore, since credits are not payable

4965

1

            run_to_session(3u32);

4966

1

            // Nobody should be assigned to para 1001

4967

1

            let assignment = CollatorAssignment::collator_container_chain();

4968

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4969

1

});

4970

1

4971

4972

#[test]

4973

1

fn test_block_credits_with_purchase_can_be_combined() {

4974

1

    ExtBuilder::default()

4975

1

        .with_balances(vec![

4976

1

            // Alice gets 10k extra tokens for her mapping deposit

4977

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4978

1

            (AccountId::from(BOB), 100_000 * UNIT),

4979

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4980

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4981

1

])

4982

1

        .with_collators(vec![

4983

1

            (AccountId::from(ALICE), 210 * UNIT),

4984

1

            (AccountId::from(BOB), 100 * UNIT),

4985

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4986

1

            (AccountId::from(DAVE), 100 * UNIT),

4987

1

])

4988

1

        .build()

4989

1

        .execute_with(|| {

4990

1

            run_to_block(2);

4991

1

            // Assert current slot gets updated

4992

1

            assert_eq!(current_slot(), 1u64);

4993

1

            assert!(current_author() == AccountId::from(BOB));

4994

4995

            // Alice and Bob collate in our chain

4996

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4997

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4998

1

4999

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5000

5001

1

            assert_ok!(Registrar::register(

5002

1

                origin_of(ALICE.into()),

5003

1

                1001.into(),

5004

1

                empty_genesis_data(),

5005

1

                None

5006

1

));

5007

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5008

1

            assert_ok!(Registrar::mark_valid_for_collating(

5009

1

                root_origin(),

5010

1

                1001.into()

5011

1

));

5012

            // Need to reset credits to 0 because now parachains are given free credits on register

5013

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5014

1

                root_origin(),

5015

1

                1001.into(),

5016

1

                crate::Period::get()

5017

1

));

5018

1

            let credits_1001 = block_credits_to_required_balance(crate::Period::get(), 1001.into())

5019

1

                + crate::EXISTENTIAL_DEPOSIT;

5020

1

5021

1

            // Fill the tank

5022

1

            assert_ok!(ServicesPayment::purchase_credits(

5023

1

                origin_of(ALICE.into()),

5024

1

                1001.into(),

5025

1

                credits_1001

5026

1

));

5027

5028

            // Assignment should happen after 2 sessions

5029

1

            run_to_session(1u32);

5030

1

            let assignment = CollatorAssignment::collator_container_chain();

5031

1

            assert!(assignment.container_chains.is_empty());

5032

1

            run_to_session(2u32);

5033

1

            // Charlie and Dave should be assigned to para 1001

5034

1

            let assignment = CollatorAssignment::collator_container_chain();

5035

1

            assert_eq!(

5036

1

                assignment.container_chains[&1001u32.into()],

5037

1

                vec![CHARLIE.into(), DAVE.into()]

5038

1

);

5039

1

});

5040

1

5041

5042

#[test]

5043

1

fn stream_payment_works() {

5044

1

    ExtBuilder::default()

5045

1

        .with_balances(vec![

5046

1

            (AccountId::from(ALICE), 100_000 * UNIT),

5047

1

            (AccountId::from(BOB), 100_000 * UNIT),

5048

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5049

1

])

5050

1

        .with_collators(vec![

5051

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5052

1

            (AccountId::from(DAVE), 100 * UNIT),

5053

1

])

5054

1

        .build()

5055

1

        .execute_with(|| {

5056

            use pallet_stream_payment::{ChangeKind, StreamConfig};

5057

5058

1

            assert_ok!(StreamPayment::open_stream(

5059

1

                origin_of(ALICE.into()),

5060

1

                BOB.into(),

5061

1

                StreamConfig {

5062

1

                    rate: 2 * UNIT,

5063

1

                    asset_id: StreamPaymentAssetId::Native,

5064

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

5065

1

                    minimum_request_deadline_delay: 0,

5066

1

                    soft_minimum_deposit: 0,

5067

1

},

5068

1

                1_000 * UNIT,

5069

1

));

5070

5071

1

            run_block();

5072

1

5073

1

            assert_ok!(StreamPayment::perform_payment(origin_of(CHARLIE.into()), 0));

5074

1

            assert_eq!(

5075

1

                Balances::free_balance(AccountId::from(BOB)),

5076

1

                100_000 * UNIT + 2 * UNIT

5077

1

);

5078

5079

1

            assert_ok!(StreamPayment::request_change(

5080

1

                origin_of(ALICE.into()),

5081

1

0,

5082

1

                ChangeKind::Suggestion,

5083

1

                StreamConfig {

5084

1

                    rate: 1 * UNIT,

5085

1

                    asset_id: StreamPaymentAssetId::Native,

5086

1

                    time_unit: StreamPaymentTimeUnit::BlockNumber,

5087

1

                    minimum_request_deadline_delay: 0,

5088

1

                    soft_minimum_deposit: 0,

5089

1

},

5090

1

                None,

5091

1

));

5092

5093

1

            assert_ok!(StreamPayment::accept_requested_change(

5094

1

                origin_of(BOB.into()),

5095

1

0,

5096

1

                1, // nonce

5097

1

                None,

5098

1

));

5099

5100

1

            run_block();

5101

1

5102

1

            assert_ok!(StreamPayment::close_stream(origin_of(BOB.into()), 0));

5103

5104

1

            assert_eq!(

5105

1

                Balances::free_balance(AccountId::from(BOB)),

5106

1

                100_000 * UNIT + 3 * UNIT

5107

1

);

5108

1

            assert_eq!(

5109

1

                Balances::free_balance(AccountId::from(ALICE)),

5110

1

                100_000 * UNIT - 3 * UNIT

5111

1

);

5112

1

});

5113

1

5114

5115

#[test]

5116

1

fn test_ed_plus_collator_assignment_session_purchase_works() {

5117

1

    ExtBuilder::default()

5118

1

        .with_balances(vec![

5119

1

            // Alice gets 10k extra tokens for her mapping deposit

5120

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5121

1

            (AccountId::from(BOB), 100_000 * UNIT),

5122

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5123

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5124

1

])

5125

1

        .with_collators(vec![

5126

1

            (AccountId::from(ALICE), 210 * UNIT),

5127

1

            (AccountId::from(BOB), 100 * UNIT),

5128

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5129

1

            (AccountId::from(DAVE), 100 * UNIT),

5130

1

])

5131

1

        .build()

5132

1

        .execute_with(|| {

5133

1

            run_to_block(2);

5134

1

            // Assert current slot gets updated

5135

1

            assert_eq!(current_slot(), 1u64);

5136

1

            assert!(current_author() == AccountId::from(BOB));

5137

5138

            // Alice and Bob collate in our chain

5139

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5140

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5141

1

5142

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5143

5144

1

            assert_ok!(Registrar::register(

5145

1

                origin_of(ALICE.into()),

5146

1

                1001.into(),

5147

1

                empty_genesis_data(),

5148

1

                None

5149

1

));

5150

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5151

1

            assert_ok!(Registrar::mark_valid_for_collating(

5152

1

                root_origin(),

5153

1

                1001.into()

5154

1

));

5155

            // Need to reset credits to 0 because now parachains are given free credits on register

5156

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5157

1

                root_origin(),

5158

1

                1001.into(),

5159

1

5160

1

));

5161

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5162

1

                + crate::EXISTENTIAL_DEPOSIT;

5163

1

5164

1

            // Fill the tank

5165

1

            assert_ok!(ServicesPayment::purchase_credits(

5166

1

                origin_of(ALICE.into()),

5167

1

                1001.into(),

5168

1

                credits_1001

5169

1

));

5170

5171

            // Assignment should happen after 2 sessions

5172

1

            run_to_session(1u32);

5173

1

            let assignment = CollatorAssignment::collator_container_chain();

5174

1

            assert!(assignment.container_chains.is_empty());

5175

1

            run_to_session(2u32);

5176

1

            // Charlie and Dave should be assigned to para 1001

5177

1

            let assignment = CollatorAssignment::collator_container_chain();

5178

1

            assert_eq!(

5179

1

                assignment.container_chains[&1001u32.into()],

5180

1

                vec![CHARLIE.into(), DAVE.into()]

5181

1

);

5182

5183

            // Simulate block inclusion from container chain 1001

5184

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

5185

1

            let slot: u64 = 5;

5186

1

            let s = ParaHeaderSproofBuilderItem {

5187

1

                para_id: 1001.into(),

5188

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

5189

1

                    parent_hash: Default::default(),

5190

1

                    number: 1,

5191

1

                    state_root: Default::default(),

5192

1

                    extrinsics_root: Default::default(),

5193

1

                    digest: sp_runtime::generic::Digest {

5194

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

5195

1

},

5196

1

}),

5197

1

};

5198

1

            sproof.items.push(s);

5199

1

            set_author_noting_inherent_data(sproof);

5200

1

5201

1

            run_block();

5202

1

5203

1

            // After this it should not be assigned anymore, since credits are not payable

5204

1

            run_to_session(4u32);

5205

1

            // Nobody should be assigned to para 1001

5206

1

            let assignment = CollatorAssignment::collator_container_chain();

5207

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5208

1

});

5209

1

5210

5211

#[test]

5212

1

fn test_ed_plus_collator_assignment_credit_session_minus_1_purchase_fails() {

5213

1

    ExtBuilder::default()

5214

1

        .with_balances(vec![

5215

1

            // Alice gets 10k extra tokens for her mapping deposit

5216

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5217

1

            (AccountId::from(BOB), 100_000 * UNIT),

5218

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5219

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5220

1

])

5221

1

        .with_collators(vec![

5222

1

            (AccountId::from(ALICE), 210 * UNIT),

5223

1

            (AccountId::from(BOB), 100 * UNIT),

5224

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5225

1

            (AccountId::from(DAVE), 100 * UNIT),

5226

1

])

5227

1

        .build()

5228

1

        .execute_with(|| {

5229

1

            run_to_block(2);

5230

1

            // Assert current slot gets updated

5231

1

            assert_eq!(current_slot(), 1u64);

5232

1

            assert!(current_author() == AccountId::from(BOB));

5233

5234

            // Alice and Bob collate in our chain

5235

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5236

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5237

1

5238

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5239

5240

1

            assert_ok!(Registrar::register(

5241

1

                origin_of(ALICE.into()),

5242

1

                1001.into(),

5243

1

                empty_genesis_data(),

5244

1

                None

5245

1

));

5246

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5247

1

            assert_ok!(Registrar::mark_valid_for_collating(

5248

1

                root_origin(),

5249

1

                1001.into()

5250

1

));

5251

            // Need to reset credits to 0 because now parachains are given free credits on register

5252

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5253

1

                root_origin(),

5254

1

                1001.into(),

5255

1

5256

1

));

5257

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5258

1

                + crate::EXISTENTIAL_DEPOSIT

5259

1

                - 1;

5260

1

5261

1

            // Fill the tank

5262

1

            assert_ok!(ServicesPayment::purchase_credits(

5263

1

                origin_of(ALICE.into()),

5264

1

                1001.into(),

5265

1

                credits_1001

5266

1

));

5267

5268

            // Assignment should happen after 2 sessions

5269

1

            run_to_session(1u32);

5270

1

            let assignment = CollatorAssignment::collator_container_chain();

5271

1

            assert!(assignment.container_chains.is_empty());

5272

1

            run_to_session(2u32);

5273

1

            // Charlie and Dave should not be assigned to para 1001

5274

1

            let assignment = CollatorAssignment::collator_container_chain();

5275

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5276

1

});

5277

1

5278

5279

#[test]

5280

1

fn test_collator_assignment_credits_with_purchase_can_be_combined() {

5281

1

    ExtBuilder::default()

5282

1

        .with_balances(vec![

5283

1

            // Alice gets 10k extra tokens for her mapping deposit

5284

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5285

1

            (AccountId::from(BOB), 100_000 * UNIT),

5286

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5287

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5288

1

])

5289

1

        .with_collators(vec![

5290

1

            (AccountId::from(ALICE), 210 * UNIT),

5291

1

            (AccountId::from(BOB), 100 * UNIT),

5292

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5293

1

            (AccountId::from(DAVE), 100 * UNIT),

5294

1

])

5295

1

        .build()

5296

1

        .execute_with(|| {

5297

1

            run_to_block(2);

5298

1

            // Assert current slot gets updated

5299

1

            assert_eq!(current_slot(), 1u64);

5300

1

            assert!(current_author() == AccountId::from(BOB));

5301

5302

            // Alice and Bob collate in our chain

5303

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5304

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5305

1

5306

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5307

5308

1

            assert_ok!(Registrar::register(

5309

1

                origin_of(ALICE.into()),

5310

1

                1001.into(),

5311

1

                empty_genesis_data(),

5312

1

                None

5313

1

));

5314

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5315

1

            assert_ok!(Registrar::mark_valid_for_collating(

5316

1

                root_origin(),

5317

1

                1001.into()

5318

1

));

5319

5320

            // We assign one session to free credits

5321

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5322

1

                root_origin(),

5323

1

                1001.into(),

5324

1

5325

1

));

5326

            // We buy another session through the tank

5327

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5328

1

                + crate::EXISTENTIAL_DEPOSIT;

5329

1

5330

1

            // Fill the tank

5331

1

            assert_ok!(ServicesPayment::purchase_credits(

5332

1

                origin_of(ALICE.into()),

5333

1

                1001.into(),

5334

1

                credits_1001

5335

1

));

5336

5337

            // Assignment should happen after 2 sessions

5338

1

            run_to_session(1u32);

5339

1

            let assignment = CollatorAssignment::collator_container_chain();

5340

1

            assert!(assignment.container_chains.is_empty());

5341

1

            run_to_session(2u32);

5342

1

            // Charlie and Dave should be assigned to para 1001

5343

1

            let assignment = CollatorAssignment::collator_container_chain();

5344

1

            assert_eq!(

5345

1

                assignment.container_chains[&1001u32.into()],

5346

1

                vec![CHARLIE.into(), DAVE.into()]

5347

1

);

5348

1

});

5349

1

5350

5351

#[test]

5352

1

fn test_block_credits_and_collator_assignation_credits_through_tank() {

5353

1

    ExtBuilder::default()

5354

1

        .with_balances(vec![

5355

1

            // Alice gets 10k extra tokens for her mapping deposit

5356

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5357

1

            (AccountId::from(BOB), 100_000 * UNIT),

5358

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5359

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5360

1

])

5361

1

        .with_collators(vec![

5362

1

            (AccountId::from(ALICE), 210 * UNIT),

5363

1

            (AccountId::from(BOB), 100 * UNIT),

5364

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5365

1

            (AccountId::from(DAVE), 100 * UNIT),

5366

1

])

5367

1

        .build()

5368

1

        .execute_with(|| {

5369

1

            run_to_block(2);

5370

1

            // Assert current slot gets updated

5371

1

            assert_eq!(current_slot(), 1u64);

5372

1

            assert!(current_author() == AccountId::from(BOB));

5373

5374

            // Alice and Bob collate in our chain

5375

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5376

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5377

1

5378

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5379

5380

1

            assert_ok!(Registrar::register(

5381

1

                origin_of(ALICE.into()),

5382

1

                1001.into(),

5383

1

                empty_genesis_data(),

5384

1

                None

5385

1

));

5386

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5387

1

            assert_ok!(Registrar::mark_valid_for_collating(

5388

1

                root_origin(),

5389

1

                1001.into()

5390

1

));

5391

5392

            // We make all free credits 0

5393

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5394

1

                root_origin(),

5395

1

                1001.into(),

5396

1

5397

1

));

5398

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5399

1

                root_origin(),

5400

1

                1001.into(),

5401

1

5402

1

));

5403

5404

            // We buy 2 sessions through tank

5405

1

            let collator_assignation_credits =

5406

1

                collator_assignment_credits_to_required_balance(2, 1001.into());

5407

1

            let block_production_credits =

5408

1

                block_credits_to_required_balance(crate::Period::get() * 2, 1001.into());

5409

1

5410

1

            // Fill the tank

5411

1

            assert_ok!(ServicesPayment::purchase_credits(

5412

1

                origin_of(ALICE.into()),

5413

1

                1001.into(),

5414

1

                collator_assignation_credits

5415

1

                    + block_production_credits

5416

1

                    + crate::EXISTENTIAL_DEPOSIT

5417

1

));

5418

5419

            // Assignment should happen after 2 sessions

5420

1

            run_to_session(1u32);

5421

1

            let assignment = CollatorAssignment::collator_container_chain();

5422

1

            assert!(assignment.container_chains.is_empty());

5423

1

            run_to_session(2u32);

5424

1

            // Charlie and Dave should be assigned to para 1001

5425

1

            let assignment = CollatorAssignment::collator_container_chain();

5426

1

            assert_eq!(

5427

1

                assignment.container_chains[&1001u32.into()],

5428

1

                vec![CHARLIE.into(), DAVE.into()]

5429

1

);

5430

5431

            // After this it should not be assigned anymore, since credits are not payable

5432

1

            run_to_session(4u32);

5433

1

            // Nobody should be assigned to para 1001

5434

1

            let assignment = CollatorAssignment::collator_container_chain();

5435

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5436

1

});

5437

1

5438

5439

#[test]

5440

1

fn test_migration_services_collator_assignment_payment() {

5441

1

    ExtBuilder::default().build().execute_with(|| {

5442

1

        // Register a new parachain with no credits

5443

1

        assert_ok!(Registrar::register(

5444

1

            origin_of(ALICE.into()),

5445

1

            1001.into(),

5446

1

            empty_genesis_data(),

5447

1

            None

5448

1

));

5449

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5450

1

        assert_ok!(Registrar::mark_valid_for_collating(

5451

1

            root_origin(),

5452

1

            1001.into()

5453

1

));

5454

        // Register another parachain with no credits, do not mark this as valid for collation

5455

1

        assert_ok!(Registrar::register(

5456

1

            origin_of(ALICE.into()),

5457

1

            1002.into(),

5458

1

            empty_genesis_data(),

5459

1

            None

5460

1

));

5461

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1002.into());

5462

1

        assert_ok!(Registrar::mark_valid_for_collating(

5463

1

            root_origin(),

5464

1

            1002.into()

5465

1

));

5466

5467

        // Need to reset credits to 0 because now parachains are given free credits on register

5468

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

5469

1

            root_origin(),

5470

1

            1001.into(),

5471

1

5472

1

));

5473

1

        assert_ok!(ServicesPayment::set_collator_assignment_credits(

5474

1

            root_origin(),

5475

1

            1002.into(),

5476

1

5477

1

));

5478

5479

1

        let credits_1001 =

5480

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

5481

1

                .unwrap_or_default();

5482

1

        assert_eq!(credits_1001, 0);

5483

1

        let credits_1002 =

5484

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

5485

1

                .unwrap_or_default();

5486

1

        assert_eq!(credits_1002, 0);

5487

5488

        // Apply migration

5489

1

        let migration =

5490

1

            MigrateServicesPaymentAddCollatorAssignmentCredits::<Runtime>(Default::default());

5491

1

        migration.migrate(Default::default());

5492

1

5493

1

        // Both parachains have been given credits

5494

1

        let credits_1001 =

5495

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1001))

5496

1

                .unwrap_or_default();

5497

1

        assert_eq!(credits_1001, crate::FreeCollatorAssignmentCredits::get());

5498

1

        let credits_1002 =

5499

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

5500

1

                .unwrap_or_default();

5501

1

        assert_eq!(credits_1002, crate::FreeCollatorAssignmentCredits::get());

5502

1

});

5503

1

5504

5505

#[test]

5506

1

fn test_max_collators_uses_pending_value() {

5507

1

    // Start with max_collators = 100, and collators_per_container = 2

5508

1

    // Set max_collators = 2, and collators_per_container = 3

5509

1

    // It should be impossible to have more than 2 collators per container at any point in time

5510

1

    ExtBuilder::default()

5511

1

        .with_balances(vec![

5512

1

            // Alice gets 10k extra tokens for her mapping deposit

5513

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5514

1

            (AccountId::from(BOB), 100_000 * UNIT),

5515

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5516

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5517

1

])

5518

1

        .with_collators(vec![

5519

1

            (AccountId::from(ALICE), 210 * UNIT),

5520

1

            (AccountId::from(BOB), 100 * UNIT),

5521

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5522

1

            (AccountId::from(DAVE), 100 * UNIT),

5523

1

])

5524

1

        .with_empty_parachains(vec![1001])

5525

1

        .with_config(pallet_configuration::HostConfiguration {

5526

1

            max_collators: 100,

5527

1

            min_orchestrator_collators: 1,

5528

1

            max_orchestrator_collators: 1,

5529

1

            collators_per_container: 2,

5530

1

            full_rotation_period: 24,

5531

1

            ..Default::default()

5532

1

})

5533

1

        .build()

5534

1

        .execute_with(|| {

5535

1

            run_to_block(2);

5536

1

5537

1

            // Initial assignment: 1 collator in orchestrator chain and 2 collators in container 1001

5538

1

            let assignment = CollatorAssignment::collator_container_chain();

5539

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 2);

5540

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5541

5542

1

            assert_ok!(Configuration::set_max_collators(root_origin(), 2));

5543

1

            assert_ok!(Configuration::set_collators_per_container(root_origin(), 3));

5544

5545

            // Check invariant for all intermediate assignments. We set collators_per_container = 3

5546

            // but we also set max_collators = 2, so no collators will be assigned to container

5547

            // chains after the change is applied.

5548

5

            for session in 1..=4 {

5549

4

                run_to_session(session);

5550

4

5551

4

                let assignment = CollatorAssignment::collator_container_chain();

5552

4

                assert!(

5553

4

                    assignment.container_chains[&1001u32.into()].len() <= 2,

5554

                    "session {}: {} collators assigned to container chain 1001",

5555

                    session,

5556

                    assignment.container_chains[&1001u32.into()].len()

5557

);

5558

5559

5560

            // Final assignment: because max_collators = 2, there are only 2 collators, one in

5561

            // orchestrator chain, and the other one idle

5562

1

            let assignment = CollatorAssignment::collator_container_chain();

5563

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 0);

5564

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5565

1

});

5566

1

5567

5568

#[test]

5569

1

fn test_slow_adjusting_multiplier_changes_in_response_to_consumed_weight() {

5570

1

    ExtBuilder::default()

5571

1

        .with_collators(vec![

5572

1

            (AccountId::from(ALICE), 210 * UNIT),

5573

1

            (AccountId::from(BOB), 100 * UNIT),

5574

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5575

1

            (AccountId::from(DAVE), 100 * UNIT),

5576

1

])

5577

1

        .build()

5578

1

        .execute_with(|| {

5579

1

            end_block();

5580

1

            // If the block is full, the multiplier increases

5581

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5582

1

            start_block();

5583

1

            let max_block_weights = crate::RuntimeBlockWeights::get();

5584

1

            frame_support::storage::unhashed::put(

5585

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5586

3

                &ConsumedWeight::new(|class| {

5587

3

                    max_block_weights

5588

3

                        .get(class)

5589

3

                        .max_total

5590

3

                        .unwrap_or(Weight::MAX)

5591

3

}),

5592

1

);

5593

1

            end_block();

5594

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5595

1

            assert!(current_multiplier > before_multiplier);

5596

5597

            // If the block is empty, the multiplier decreases

5598

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5599

1

            start_block();

5600

1

            frame_support::storage::unhashed::put(

5601

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5602

3

                &ConsumedWeight::new(|_class| Weight::zero()),

5603

1

);

5604

1

            end_block();

5605

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5606

1

            assert!(current_multiplier < before_multiplier);

5607

1

});

5608

1

5609

5610

#[test]

5611

1

fn test_collator_assignment_tip_priority_on_congestion() {

5612

1

    ExtBuilder::default()

5613

1

        .with_balances(vec![

5614

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5615

1

            (AccountId::from(BOB), 100_000 * UNIT),

5616

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5617

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5618

1

])

5619

1

        .with_collators(vec![

5620

1

            (AccountId::from(ALICE), 210 * UNIT),

5621

1

            (AccountId::from(BOB), 100 * UNIT),

5622

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5623

1

            (AccountId::from(DAVE), 100 * UNIT),

5624

1

])

5625

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5626

1

        .build()

5627

1

        .execute_with(|| {

5628

1

            let para_id = 1003u32;

5629

1

            let tank_funds = 100 * UNIT;

5630

1

            let max_tip = 1 * UNIT;

5631

1

5632

1

            assert_eq!(

5633

1

                CollatorAssignment::collator_container_chain().container_chains[&1003u32.into()]

5634

1

                    .len(),

5635

1

5636

1

);

5637

5638

            // Send funds to tank

5639

1

            assert_ok!(ServicesPayment::purchase_credits(

5640

1

                origin_of(ALICE.into()),

5641

1

                para_id.into(),

5642

1

                tank_funds,

5643

1

));

5644

5645

            // Set tip for 1003

5646

1

            assert_ok!(ServicesPayment::set_max_tip(

5647

1

                root_origin(),

5648

1

                para_id.into(),

5649

1

                Some(max_tip),

5650

1

));

5651

5652

1

            run_to_session(2);

5653

1

            assert_eq!(

5654

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5655

1

                    .len(),

5656

1

2,

5657

1

);

5658

1

});

5659

1

5660

5661

#[test]

5662

1

fn test_collator_assignment_tip_charged_on_congestion() {

5663

1

    ExtBuilder::default()

5664

1

        .with_balances(vec![

5665

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5666

1

            (AccountId::from(BOB), 100_000 * UNIT),

5667

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5668

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5669

1

])

5670

1

        .with_collators(vec![

5671

1

            (AccountId::from(ALICE), 210 * UNIT),

5672

1

            (AccountId::from(BOB), 100 * UNIT),

5673

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5674

1

            (AccountId::from(DAVE), 100 * UNIT),

5675

1

])

5676

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5677

1

        .build()

5678

1

        .execute_with(|| {

5679

1

            let tank_funds = 100 * UNIT;

5680

1

            let max_tip = 1 * UNIT;

5681

1

            let para_id = 1003u32;

5682

1

5683

1

            // Send funds to tank

5684

1

            assert_ok!(ServicesPayment::purchase_credits(

5685

1

                origin_of(ALICE.into()),

5686

1

                para_id.into(),

5687

1

                tank_funds,

5688

1

));

5689

5690

            // Set tip for para_id

5691

1

            assert_ok!(ServicesPayment::set_max_tip(

5692

1

                root_origin(),

5693

1

                para_id.into(),

5694

1

                Some(max_tip),

5695

1

));

5696

5697

1

            run_to_session(1);

5698

1

            assert_eq!(

5699

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id.into())),

5700

1

                tank_funds - max_tip,

5701

1

);

5702

1

});

5703

1

5704

5705

#[test]

5706

1

fn test_collator_assignment_tip_not_assigned_on_insufficient_balance() {

5707

1

    ExtBuilder::default()

5708

1

        .with_balances(vec![

5709

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5710

1

            (AccountId::from(BOB), 100_000 * UNIT),

5711

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5712

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5713

1

])

5714

1

        .with_collators(vec![

5715

1

            (AccountId::from(ALICE), 210 * UNIT),

5716

1

            (AccountId::from(BOB), 100 * UNIT),

5717

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5718

1

            (AccountId::from(DAVE), 100 * UNIT),

5719

1

])

5720

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5721

1

        .build()

5722

1

        .execute_with(|| {

5723

1

            let tank_funds = 1 * UNIT;

5724

1

            let max_tip = 1 * UNIT;

5725

1

            let para_id = 1003u32;

5726

1

5727

1

            // Send insufficient funds to tank for tip for 2 sessions

5728

1

            assert_ok!(ServicesPayment::purchase_credits(

5729

1

                origin_of(ALICE.into()),

5730

1

                para_id.into(),

5731

1

                tank_funds,

5732

1

));

5733

5734

            // Set tip for para_id

5735

1

            assert_ok!(ServicesPayment::set_max_tip(

5736

1

                root_origin(),

5737

1

                para_id.into(),

5738

1

                Some(max_tip),

5739

1

));

5740

5741

1

            run_to_session(1);

5742

1

            assert_eq!(

5743

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5744

1

                    .len(),

5745

1

5746

1

);

5747

1

});

5748

1

5749

5750

#[test]

5751

1

fn test_collator_assignment_tip_only_charge_willing_paras() {

5752

1

    ExtBuilder::default()

5753

1

        .with_balances(vec![

5754

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5755

1

            (AccountId::from(BOB), 100_000 * UNIT),

5756

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5757

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5758

1

            (AccountId::from(EVE), 100_000 * UNIT),

5759

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5760

1

])

5761

1

        .with_collators(vec![

5762

1

            (AccountId::from(ALICE), 210 * UNIT),

5763

1

            (AccountId::from(BOB), 100 * UNIT),

5764

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5765

1

            (AccountId::from(DAVE), 100 * UNIT),

5766

1

            (AccountId::from(EVE), 100 * UNIT),

5767

1

            (AccountId::from(FERDIE), 100 * UNIT),

5768

1

])

5769

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5770

1

        .build()

5771

1

        .execute_with(|| {

5772

1

            let tank_funds = 100 * UNIT;

5773

1

            let max_tip = 1 * UNIT;

5774

1

            let para_id_with_tip = 1003u32;

5775

1

            let para_id_without_tip = 1001u32;

5776

1

5777

1

            // Send funds to tank to both paras

5778

1

            assert_ok!(ServicesPayment::purchase_credits(

5779

1

                origin_of(ALICE.into()),

5780

1

                para_id_with_tip.into(),

5781

1

                tank_funds,

5782

1

));

5783

1

            assert_ok!(ServicesPayment::purchase_credits(

5784

1

                origin_of(ALICE.into()),

5785

1

                para_id_without_tip.into(),

5786

1

                tank_funds,

5787

1

));

5788

5789

            // Only set tip for 1003

5790

1

            assert_ok!(ServicesPayment::set_max_tip(

5791

1

                root_origin(),

5792

1

                para_id_with_tip.into(),

5793

1

                Some(max_tip),

5794

1

));

5795

5796

1

            run_to_session(2);

5797

1

5798

1

            let assignment = CollatorAssignment::collator_container_chain().container_chains;

5799

1

5800

1

            // 2 out of the 3 paras should have collators assigned, with one paying tip to get

5801

1

            // prioritized, and the other selected at random that should not be charged any tips

5802

1

            assert_eq!(assignment[&para_id_with_tip.into()].len(), 2);

5803

1

            assert_eq!(

5804

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_with_tip.into())),

5805

1

                tank_funds - max_tip * 2,

5806

1

);

5807

5808

1

            assert_eq!(assignment[&para_id_without_tip.into()].len(), 2);

5809

1

            assert_eq!(

5810

1

                Balances::usable_balance(ServicesPayment::parachain_tank(

5811

1

                    para_id_without_tip.into()

5812

1

)),

5813

1

                tank_funds,

5814

1

);

5815

1

});

5816

1

5817

5818

#[test]

5819

1

fn test_collator_assignment_tip_withdraw_min_tip() {

5820

1

    ExtBuilder::default()

5821

1

        .with_balances(vec![

5822

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5823

1

            (AccountId::from(BOB), 100_000 * UNIT),

5824

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5825

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5826

1

            (AccountId::from(EVE), 100_000 * UNIT),

5827

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5828

1

])

5829

1

        .with_collators(vec![

5830

1

            (AccountId::from(ALICE), 210 * UNIT),

5831

1

            (AccountId::from(BOB), 100 * UNIT),

5832

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5833

1

            (AccountId::from(DAVE), 100 * UNIT),

5834

1

            (AccountId::from(EVE), 100 * UNIT),

5835

1

            (AccountId::from(FERDIE), 100 * UNIT),

5836

1

])

5837

1

        .with_empty_parachains(vec![1001, 1002, 1003])

5838

1

        .build()

5839

1

        .execute_with(|| {

5840

1

            let tank_funds = 100 * UNIT;

5841

1

            let max_tip_1003 = 3 * UNIT;

5842

1

            let max_tip_1002 = 2 * UNIT;

5843

1

            let para_id_1003 = 1003u32;

5844

1

            let para_id_1002 = 1002u32;

5845

1

5846

1

            // Send funds to tank to both paras

5847

1

            assert_ok!(ServicesPayment::purchase_credits(

5848

1

                origin_of(ALICE.into()),

5849

1

                para_id_1003.into(),

5850

1

                tank_funds,

5851

1

));

5852

1

            assert_ok!(ServicesPayment::purchase_credits(

5853

1

                origin_of(ALICE.into()),

5854

1

                para_id_1002.into(),

5855

1

                tank_funds,

5856

1

));

5857

5858

            // Set tips

5859

1

            assert_ok!(ServicesPayment::set_max_tip(

5860

1

                root_origin(),

5861

1

                para_id_1003.into(),

5862

1

                Some(max_tip_1003),

5863

1

));

5864

1

            assert_ok!(ServicesPayment::set_max_tip(

5865

1

                root_origin(),

5866

1

                para_id_1002.into(),

5867

1

                Some(max_tip_1002),

5868

1

));

5869

5870

1

            run_to_session(2);

5871

1

5872

1

            assert_eq!(

5873

1

                CollatorAssignment::collator_container_chain().container_chains

5874

1

                    [&para_id_1003.into()]

5875

1

                    .len(),

5876

1

5877

1

);

5878

1

            assert_eq!(

5879

1

                CollatorAssignment::collator_container_chain().container_chains

5880

1

                    [&para_id_1002.into()]

5881

1

                    .len(),

5882

1

5883

1

);

5884

5885

            // Should have withdrawn the lowest tip from both paras

5886

1

            assert_eq!(

5887

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1003.into())),

5888

1

                tank_funds - max_tip_1002 * 2,

5889

1

);

5890

5891

1

            assert_eq!(

5892

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1002.into())),

5893

1

                tank_funds - max_tip_1002 * 2,

5894

1

);

5895

1

});

5896

1

5897

5898

#[test]

5899

1

fn test_migration_data_preservers_assignments() {

5900

1

    ExtBuilder::default().build().execute_with(|| {

5901

        use {

5902

            crate::{MaxAssignmentsPerParaId, MaxNodeUrlLen},

5903

            frame_support::{

5904

                migration::{have_storage_value, put_storage_value},

5905

                Blake2_128Concat, StorageHasher,

5906

},

5907

            pallet_data_preservers::{ParaIdsFilter, Profile, ProfileMode, RegisteredProfile},

5908

            sp_runtime::BoundedBTreeSet,

5909

            sp_std::collections::btree_set::BTreeSet,

5910

            tanssi_runtime_common::migrations::DataPreserversAssignmentsMigration,

5911

};

5912

5913

        macro_rules! bset {

5914

            ( $($value:expr),* $(,)? ) => {

5915

5916

                    let mut set = BoundedBTreeSet::new();

5917

$(

5918

                        set.try_insert($value).expect("max bound reached");

5919

)*

5920

set

5921

5922

5923

5924

5925

        macro_rules! set {

5926

            ( $($value:expr),* $(,)? ) => {

5927

5928

                    let mut set = BTreeSet::new();

5929

$(

5930

                        set.insert($value);

5931

)*

5932

set

5933

5934

5935

5936

5937

1

        let account = AccountId::from([0u8; 32]);

5938

1

        let free_request = tp_data_preservers_common::ProviderRequest::Free;

5939

1

        let free_witness = tp_data_preservers_common::AssignmentWitness::Free;

5940

1

5941

1

        let pallet_prefix: &[u8] = b"DataPreservers";

5942

1

        let storage_item_prefix: &[u8] = b"BootNodes";

5943

1

5944

1

        // Register 2 parachains

5945

1

        assert_ok!(Registrar::register(

5946

1

            origin_of(ALICE.into()),

5947

1

            1001.into(),

5948

1

            empty_genesis_data(),

5949

1

            None

5950

1

));

5951

1

        assert_ok!(Registrar::register(

5952

1

            origin_of(BOB.into()),

5953

1

            1002.into(),

5954

1

            empty_genesis_data(),

5955

1

            None

5956

1

));

5957

5958

        // Set bootnodes in old storage

5959

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

5960

1

            b"alpha".to_vec().try_into().unwrap(),

5961

1

            b"beta".to_vec().try_into().unwrap(),

5962

1

5963

1

        .try_into()

5964

1

        .unwrap();

5965

1

        put_storage_value(

5966

1

            pallet_prefix,

5967

1

            storage_item_prefix,

5968

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode()),

5969

1

            bootnodes,

5970

1

);

5971

1

5972

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

5973

1

            b"delta".to_vec().try_into().unwrap(),

5974

1

            b"gamma".to_vec().try_into().unwrap(),

5975

1

5976

1

        .try_into()

5977

1

        .unwrap();

5978

1

        put_storage_value(

5979

1

            pallet_prefix,

5980

1

            storage_item_prefix,

5981

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode()),

5982

1

            bootnodes,

5983

1

);

5984

1

5985

1

        // Apply migration

5986

1

        let migration = DataPreserversAssignmentsMigration::<Runtime>(Default::default());

5987

1

        migration.migrate(Default::default());

5988

1

5989

1

        // Check old storage is empty

5990

1

        assert!(!have_storage_value(

5991

1

            pallet_prefix,

5992

1

            storage_item_prefix,

5993

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode())

5994

1

));

5995

1

        assert!(!have_storage_value(

5996

1

            pallet_prefix,

5997

1

            storage_item_prefix,

5998

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode())

5999

1

));

6000

6001

        // Check new storage

6002

1

        assert_eq!(

6003

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1001)).into_inner(),

6004

1

            set![0, 1]

6005

1

);

6006

1

        assert_eq!(

6007

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1002)).into_inner(),

6008

1

            set![2, 3]

6009

1

);

6010

1

        assert_eq!(pallet_data_preservers::NextProfileId::<Runtime>::get(), 4);

6011

1

        assert_eq!(

6012

1

            pallet_data_preservers::Profiles::<Runtime>::get(0),

6013

1

            Some(RegisteredProfile {

6014

1

                account: account.clone(),

6015

1

                deposit: 0,

6016

1

                assignment: Some((1001.into(), free_witness)),

6017

1

                profile: Profile {

6018

1

                    url: b"alpha".to_vec().try_into().unwrap(),

6019

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

6020

1

                    mode: ProfileMode::Bootnode,

6021

1

                    assignment_request: free_request,

6022

1

6023

1

})

6024

1

);

6025

1

        assert_eq!(

6026

1

            pallet_data_preservers::Profiles::<Runtime>::get(1),

6027

1

            Some(RegisteredProfile {

6028

1

                account: account.clone(),

6029

1

                deposit: 0,

6030

1

                assignment: Some((1001.into(), free_witness)),

6031

1

                profile: Profile {

6032

1

                    url: b"beta".to_vec().try_into().unwrap(),

6033

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

6034

1

                    mode: ProfileMode::Bootnode,

6035

1

                    assignment_request: free_request,

6036

1

6037

1

})

6038

1

);

6039

1

        assert_eq!(

6040

1

            pallet_data_preservers::Profiles::<Runtime>::get(2),

6041

1

            Some(RegisteredProfile {

6042

1

                account: account.clone(),

6043

1

                deposit: 0,

6044

1

                assignment: Some((1002.into(), free_witness)),

6045

1

                profile: Profile {

6046

1

                    url: b"delta".to_vec().try_into().unwrap(),

6047

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

6048

1

                    mode: ProfileMode::Bootnode,

6049

1

                    assignment_request: free_request,

6050

1

6051

1

})

6052

1

);

6053

1

        assert_eq!(

6054

1

            pallet_data_preservers::Profiles::<Runtime>::get(3),

6055

1

            Some(RegisteredProfile {

6056

1

                account: account.clone(),

6057

1

                deposit: 0,

6058

1

                assignment: Some((1002.into(), free_witness)),

6059

1

                profile: Profile {

6060

1

                    url: b"gamma".to_vec().try_into().unwrap(),

6061

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

6062

1

                    mode: ProfileMode::Bootnode,

6063

1

                    assignment_request: free_request,

6064

1

6065

1

})

6066

1

);

6067

1

})

6068

1

6069

6070

#[test]

6071

1

fn test_migration_registrar_reserves_to_hold() {

6072

1

    ExtBuilder::default()

6073

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

6074

1

        .build()

6075

1

        .execute_with(|| {

6076

            use {

6077

                frame_support::traits::{fungible::InspectHold, ReservableCurrency},

6078

                pallet_registrar::DepositInfo,

6079

                tanssi_runtime_common::migrations::RegistrarReserveToHoldMigration,

6080

};

6081

6082

1

            let deposit: Balance = 100 * UNIT;

6083

1

            let account: AccountId = DAVE.into();

6084

1

6085

1

            assert_ok!(Balances::reserve(&account, deposit));

6086

6087

1

            pallet_registrar::RegistrarDeposit::<Runtime>::insert(

6088

1

                ParaId::from(1001),

6089

1

                DepositInfo {

6090

1

                    creator: account.clone(),

6091

1

                    deposit,

6092

1

},

6093

1

);

6094

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

6095

            // Apply migration

6096

1

            let migration = RegistrarReserveToHoldMigration::<Runtime>(Default::default());

6097

1

            migration.migrate(Default::default());

6098

1

6099

1

            // Holds also count as reserved balance, so the total reserved amount

6100

1

            // shouldn't change after the migration

6101

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

6102

6103

1

            assert_eq!(

6104

1

                Balances::balance_on_hold(

6105

1

                    &pallet_registrar::HoldReason::RegistrarDeposit.into(),

6106

1

                    &account

6107

1

),

6108

1

                deposit

6109

1

);

6110

1

})

6111

1

6112

6113

#[test]

6114

1

fn test_migration_stream_payment_config_new_fields() {

6115

1

    ExtBuilder::default().build().execute_with(|| {

6116

        use pallet_stream_payment::{

6117

            migrations::{OldChangeRequest, OldStream, OldStreamConfig},

6118

            ChangeKind, ChangeRequest, DepositChange, Party, Stream, StreamConfig,

6119

};

6120

        use tanssi_runtime_common::migrations::MigrateStreamPaymentNewConfigFields;

6121

6122

1

        frame_support::storage::unhashed::put(

6123

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(0),

6124

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

6125

1

                source: ALICE.into(),

6126

1

                target: BOB.into(),

6127

1

                config: OldStreamConfig {

6128

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

6129

1

                    asset_id: StreamPaymentAssetId::Native,

6130

1

                    rate: 41,

6131

1

},

6132

1

                deposit: 42,

6133

1

                last_time_updated: 43,

6134

1

                request_nonce: 44,

6135

1

                pending_request: Some(OldChangeRequest {

6136

1

                    requester: Party::Source,

6137

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

6138

1

                    new_config: OldStreamConfig {

6139

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

6140

1

                        asset_id: StreamPaymentAssetId::Native,

6141

1

                        rate: 46,

6142

1

},

6143

1

                    deposit_change: Some(DepositChange::Absolute(47)),

6144

1

}),

6145

1

                opening_deposit: 48,

6146

1

},

6147

1

);

6148

1

6149

1

        frame_support::storage::unhashed::put(

6150

1

            &pallet_stream_payment::Streams::<Runtime>::hashed_key_for(1),

6151

1

            &OldStream::<AccountId, StreamPaymentTimeUnit, StreamPaymentAssetId, Balance> {

6152

1

                source: CHARLIE.into(),

6153

1

                target: ALICE.into(),

6154

1

                config: OldStreamConfig {

6155

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

6156

1

                    asset_id: StreamPaymentAssetId::Native,

6157

1

                    rate: 100,

6158

1

},

6159

1

                deposit: 101,

6160

1

                last_time_updated: 102,

6161

1

                request_nonce: 103,

6162

1

                pending_request: None,

6163

1

                opening_deposit: 104,

6164

1

},

6165

1

);

6166

1

6167

1

        let migration = MigrateStreamPaymentNewConfigFields::<Runtime>(Default::default());

6168

1

        migration.migrate(Default::default());

6169

1

6170

1

        assert_eq!(

6171

1

            pallet_stream_payment::Streams::<Runtime>::get(0).unwrap(),

6172

1

            Stream {

6173

1

                source: ALICE.into(),

6174

1

                target: BOB.into(),

6175

1

                config: StreamConfig {

6176

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

6177

1

                    asset_id: StreamPaymentAssetId::Native,

6178

1

                    rate: 41,

6179

1

                    minimum_request_deadline_delay: 0,

6180

1

                    soft_minimum_deposit: 0,

6181

1

},

6182

1

                deposit: 42,

6183

1

                last_time_updated: 43,

6184

1

                request_nonce: 44,

6185

1

                pending_request: Some(ChangeRequest {

6186

1

                    requester: Party::Source,

6187

1

                    kind: ChangeKind::Mandatory { deadline: 45 },

6188

1

                    new_config: StreamConfig {

6189

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

6190

1

                        asset_id: StreamPaymentAssetId::Native,

6191

1

                        rate: 46,

6192

1

                        minimum_request_deadline_delay: 0,

6193

1

                        soft_minimum_deposit: 0,

6194

1

},

6195

1

                    deposit_change: Some(DepositChange::Absolute(47)),

6196

1

}),

6197

1

                opening_deposit: 48,

6198

1

6199

1

);

6200

6201

1

        assert_eq!(

6202

1

            pallet_stream_payment::Streams::<Runtime>::get(1).unwrap(),

6203

1

            Stream {

6204

1

                source: CHARLIE.into(),

6205

1

                target: ALICE.into(),

6206

1

                config: StreamConfig {

6207

1

                    time_unit: StreamPaymentTimeUnit::Timestamp,

6208

1

                    asset_id: StreamPaymentAssetId::Native,

6209

1

                    rate: 100,

6210

1

                    minimum_request_deadline_delay: 0,

6211

1

                    soft_minimum_deposit: 0,

6212

1

},

6213

1

                deposit: 101,

6214

1

                last_time_updated: 102,

6215

1

                request_nonce: 103,

6216

1

                pending_request: None,

6217

1

                opening_deposit: 104,

6218

1

6219

1

);

6220

1

})

6221

1

6222

6223

#[test]

6224

1

fn test_migration_pooled_staking_summaries() {

6225

1

    ExtBuilder::default()

6226

1

        .with_balances(vec![

6227

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6228

1

            (AccountId::from(BOB), 100_000 * UNIT),

6229

1

])

6230

1

        .build()

6231

1

        .execute_with(|| {

6232

            use pallet_pooled_staking::{

6233

                CandidateSummaries, CandidateSummary, DelegatorCandidateSummaries,

6234

                DelegatorCandidateSummary, Pools, PoolsKey,

6235

};

6236

6237

            // We'll write directly shares to storage, then run the migrations and

6238

            // checks the summaries matches.

6239

6240

1

            let alice = AccountId::from(ALICE);

6241

1

            let bob = AccountId::from(BOB);

6242

1

            let charlie = AccountId::from(CHARLIE);

6243

1

6244

1

            Pools::<Runtime>::insert(

6245

1

                alice.clone(),

6246

1

                PoolsKey::JoiningShares {

6247

1

                    delegator: alice.clone(),

6248

1

},

6249

1

42,

6250

1

);

6251

1

            Pools::<Runtime>::insert(

6252

1

                alice.clone(),

6253

1

                PoolsKey::AutoCompoundingShares {

6254

1

                    delegator: bob.clone(),

6255

1

},

6256

1

42,

6257

1

);

6258

1

6259

1

            Pools::<Runtime>::insert(

6260

1

                bob.clone(),

6261

1

                PoolsKey::ManualRewardsShares {

6262

1

                    delegator: alice.clone(),

6263

1

},

6264

1

42,

6265

1

);

6266

1

6267

1

            // let's test 0 value is ignored

6268

1

            Pools::<Runtime>::insert(

6269

1

                bob.clone(),

6270

1

                PoolsKey::ManualRewardsShares {

6271

1

                    delegator: charlie.clone(),

6272

1

},

6273

1

0,

6274

1

);

6275

1

6276

1

            // Run migration

6277

1

            StorageVersion::new(0u16).put::<PooledStaking>(); // set version required for migration to run

6278

1

            pallet_pooled_staking::migrations::MigrationGenerateSummaries::<Runtime>::step(

6279

1

                None,

6280

1

                &mut WeightMeter::new(),

6281

1

6282

1

            .expect("to run without errors");

6283

1

6284

1

            // Check output

6285

1

            assert_eq!(CandidateSummaries::<Runtime>::iter().count(), 2);

6286

1

            assert_eq!(

6287

1

                CandidateSummaries::<Runtime>::get(&alice),

6288

1

                CandidateSummary {

6289

1

                    delegators: 2,

6290

1

                    joining_delegators: 1,

6291

1

                    auto_compounding_delegators: 1,

6292

1

                    ..Default::default()

6293

1

6294

1

);

6295

1

            assert_eq!(

6296

1

                CandidateSummaries::<Runtime>::get(&bob),

6297

1

                CandidateSummary {

6298

1

                    delegators: 1,

6299

1

                    manual_rewards_delegators: 1,

6300

1

                    ..Default::default()

6301

1

6302

1

);

6303

6304

1

            assert_eq!(DelegatorCandidateSummaries::<Runtime>::iter().count(), 3);

6305

1

            assert_eq!(

6306

1

                DelegatorCandidateSummaries::<Runtime>::get(&alice, &alice),

6307

1

                DelegatorCandidateSummary::default().with_joining(true)

6308

1

);

6309

1

            assert_eq!(

6310

1

                DelegatorCandidateSummaries::<Runtime>::get(&alice, &bob),

6311

1

                DelegatorCandidateSummary::default().with_manual(true)

6312

1

);

6313

1

            assert_eq!(

6314

1

                DelegatorCandidateSummaries::<Runtime>::get(&bob, &alice),

6315

1

                DelegatorCandidateSummary::default().with_auto(true)

6316

1

);

6317

1

});

6318

1

6319

6320

#[test]

6321

1

fn test_container_deregister_unassign_data_preserver() {

6322

1

    ExtBuilder::default()

6323

1

        .with_balances(vec![

6324

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6325

1

            (AccountId::from(BOB), 100_000 * UNIT),

6326

1

])

6327

1

        .build()

6328

1

        .execute_with(|| {

6329

            use pallet_data_preservers::{

6330

                AssignerParameterOf, ParaIdsFilter, Profile, ProfileMode, ProviderRequestOf,

6331

};

6332

6333

1

            let profile = Profile {

6334

1

                url: b"test".to_vec().try_into().unwrap(),

6335

1

                para_ids: ParaIdsFilter::AnyParaId,

6336

1

                mode: ProfileMode::Bootnode,

6337

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

6338

1

};

6339

1

6340

1

            let para_id = ParaId::from(1002);

6341

1

            let profile_id = 0u64;

6342

1

6343

1

            assert_ok!(Registrar::register(

6344

1

                origin_of(ALICE.into()),

6345

1

                para_id,

6346

1

                empty_genesis_data(),

6347

1

                None

6348

1

));

6349

6350

1

            assert_ok!(DataPreservers::create_profile(

6351

1

                origin_of(BOB.into()),

6352

1

                profile.clone(),

6353

1

));

6354

6355

            // Start assignment

6356

1

            assert_ok!(DataPreservers::start_assignment(

6357

1

                origin_of(ALICE.into()),

6358

1

                profile_id,

6359

1

                para_id,

6360

1

                AssignerParameterOf::<Runtime>::Free

6361

1

));

6362

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&0u64));

6363

6364

            // Deregister from Registrar

6365

1

            assert_ok!(Registrar::deregister(root_origin(), para_id), ());

6366

6367

            // Check DataPreserver assignment has been cleared

6368

1

            assert!(pallet_data_preservers::Assignments::<Runtime>::get(para_id).is_empty());

6369

1

});

6370

1

6371

6372

#[test]

6373

1

fn test_data_preserver_with_stream_payment() {

6374

1

    ExtBuilder::default()

6375

1

        .with_balances(vec![

6376

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6377

1

            (AccountId::from(BOB), 100_000 * UNIT),

6378

1

])

6379

1

        .build()

6380

1

        .execute_with(|| {

6381

            use pallet_data_preservers::{

6382

                AssignerParameterOf, ParaIdsFilter, Profile, ProfileMode, ProviderRequestOf,

6383

};

6384

6385

1

            let profile = Profile {

6386

1

                url: b"test".to_vec().try_into().unwrap(),

6387

1

                para_ids: ParaIdsFilter::AnyParaId,

6388

1

                mode: ProfileMode::Bootnode,

6389

1

                assignment_request: ProviderRequestOf::<Runtime>::StreamPayment {

6390

1

                    config: StreamConfig {

6391

1

                        time_unit: StreamPaymentTimeUnit::BlockNumber,

6392

1

                        asset_id: StreamPaymentAssetId::Native,

6393

1

                        rate: 42,

6394

1

                        minimum_request_deadline_delay: 0,

6395

1

                        soft_minimum_deposit: 0,

6396

1

},

6397

1

},

6398

1

};

6399

1

6400

1

            let para_id = ParaId::from(1002);

6401

1

            let profile_id = 0u64;

6402

1

6403

1

            assert_ok!(Registrar::register(

6404

1

                origin_of(ALICE.into()),

6405

1

                para_id,

6406

1

                empty_genesis_data(),

6407

1

                None

6408

1

));

6409

6410

1

            assert_ok!(DataPreservers::create_profile(

6411

1

                origin_of(BOB.into()),

6412

1

                profile.clone(),

6413

1

));

6414

6415

            // Start assignment

6416

1

            assert_ok!(DataPreservers::start_assignment(

6417

1

                origin_of(ALICE.into()),

6418

1

                profile_id,

6419

1

                para_id,

6420

1

                AssignerParameterOf::<Runtime>::StreamPayment {

6421

1

                    initial_deposit: 1_000

6422

1

6423

1

));

6424

1

            assert!(

6425

1

                pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&profile_id)

6426

1

);

6427

1

            let profile = pallet_data_preservers::Profiles::<Runtime>::get(&profile_id)

6428

1

                .expect("profile to exists");

6429

1

            let (assigned_para_id, witness) = profile.assignment.expect("profile to be assigned");

6430

1

            assert_eq!(assigned_para_id, para_id);

6431

1

            assert_eq!(

6432

1

                witness,

6433

1

                tp_data_preservers_common::AssignmentWitness::StreamPayment { stream_id: 0 }

6434

1

);

6435

1

});

6436

1

6437

6438

#[test]

6439

1

fn test_data_preserver_kind_needs_to_match() {

6440

1

    ExtBuilder::default()

6441

1

        .with_balances(vec![

6442

1

            (AccountId::from(ALICE), 210_000 * UNIT),

6443

1

            (AccountId::from(BOB), 100_000 * UNIT),

6444

1

])

6445

1

        .build()

6446

1

        .execute_with(|| {

6447

            use pallet_data_preservers::{

6448

                AssignerParameterOf, ParaIdsFilter, Profile, ProfileMode, ProviderRequestOf,

6449

};

6450

6451

1

            let profile = Profile {

6452

1

                url: b"test".to_vec().try_into().unwrap(),

6453

1

                para_ids: ParaIdsFilter::AnyParaId,

6454

1

                mode: ProfileMode::Bootnode,

6455

1

                assignment_request: ProviderRequestOf::<Runtime>::Free,

6456

1

};

6457

1

6458

1

            let para_id = ParaId::from(1002);

6459

1

            let profile_id = 0u64;

6460

1

6461

1

            assert_ok!(Registrar::register(

6462

1

                origin_of(ALICE.into()),

6463

1

                para_id,

6464

1

                empty_genesis_data(),

6465

1

                None

6466

1

));

6467

6468

1

            assert_ok!(DataPreservers::create_profile(

6469

1

                origin_of(BOB.into()),

6470

1

                profile.clone(),

6471

1

));

6472

6473

            // Start assignment

6474

1

            assert_err!(

6475

1

                DataPreservers::start_assignment(

6476

1

                    origin_of(ALICE.into()),

6477

1

                    profile_id,

6478

1

                    para_id,

6479

1

                    AssignerParameterOf::<Runtime>::StreamPayment {

6480

1

                        initial_deposit: 1_000

6481

1

6482

1

),

6483

1

                pallet_data_preservers::Error::<Runtime>::AssignmentPaymentRequestParameterMismatch

6484

1

);

6485

1

});

6486

1

6487

6488

#[test]

6489

1

fn test_registrar_extrinsic_permissions() {

6490

1

    ExtBuilder::default()

6491

1

        .with_balances(vec![

6492

1

6493

1

                cumulus_primitives_core::relay_chain::AccountId::from(ALICE),

6494

1

                210_000 * UNIT,

6495

1

),

6496

1

6497

1

                cumulus_primitives_core::relay_chain::AccountId::from(BOB),

6498

1

                100_000 * UNIT,

6499

1

),

6500

1

])

6501

1

        .with_empty_parachains(vec![1001])

6502

1

        .build()

6503

1

        .execute_with(|| {

6504

1

            let para_id = ParaId::from(1001);

6505

1

6506

1

            // Pause container chain should fail if not para manager

6507

1

            assert_noop!(

6508

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

6509

1

                BadOrigin

6510

1

);

6511

6512

            // Set Bob as para manager

6513

1

            assert_ok!(Registrar::set_para_manager(

6514

1

                root_origin(),

6515

1

                para_id,

6516

1

                AccountId::from(BOB)

6517

1

));

6518

6519

            // Pause container chain should succeed if para manager

6520

1

            assert_ok!(

6521

1

                Registrar::pause_container_chain(origin_of(BOB.into()), para_id),

6522

1

()

6523

1

);

6524

1

});

6525

1