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

    common::*,

21

    cumulus_primitives_core::ParaId,

22

    dancebox_runtime::{

23

        xcm_config::ForeignAssetsInstance, RewardsCollatorCommission, StreamPayment,

24

        StreamPaymentAssetId, TimeUnit, TransactionPayment,

25

},

26

    dp_consensus::runtime_decl_for_tanssi_authority_assignment_api::TanssiAuthorityAssignmentApiV1,

27

    dp_core::well_known_keys,

28

    frame_support::{

29

        assert_noop, assert_ok, migration::put_storage_value, storage::generator::StorageMap,

30

        BoundedVec, Hashable,

31

},

32

    frame_system::ConsumedWeight,

33

    nimbus_primitives::NIMBUS_KEY_ID,

34

    pallet_author_noting_runtime_api::runtime_decl_for_author_noting_api::AuthorNotingApi,

35

    pallet_balances::Instance1,

36

    pallet_collator_assignment_runtime_api::runtime_decl_for_collator_assignment_api::CollatorAssignmentApi,

37

    pallet_foreign_asset_creator::{AssetIdToForeignAsset, ForeignAssetToAssetId},

38

    pallet_migrations::Migration,

39

    pallet_pooled_staking::{

40

        traits::IsCandidateEligible, AllTargetPool, EligibleCandidate, PendingOperationKey,

41

        PendingOperationQuery, PoolsKey, SharesOrStake, TargetPool,

42

},

43

    pallet_registrar_runtime_api::{

44

        runtime_decl_for_registrar_api::RegistrarApi, ContainerChainGenesisData,

45

},

46

    parity_scale_codec::Encode,

47

    sp_consensus_aura::AURA_ENGINE_ID,

48

    sp_core::Get,

49

    sp_runtime::{

50

        traits::{BadOrigin, BlakeTwo256, OpaqueKeys},

51

        DigestItem, FixedU128,

52

},

53

    sp_std::vec,

54

    staging_xcm::{

55

        latest::prelude::*,

56

        v3::{

57

            Junction as V3Junction, Junctions as V3Junctions, MultiLocation as V3MultiLocation,

58

            NetworkId as V3NetworkId,

59

},

60

},

61

    std::marker::PhantomData,

62

    tanssi_runtime_common::migrations::{

63

        ForeignAssetCreatorMigration, MigrateConfigurationParathreads,

64

        MigrateServicesPaymentAddCollatorAssignmentCredits, RegistrarPendingVerificationValueToMap,

65

},

66

    test_relay_sproof_builder::{HeaderAs, ParaHeaderSproofBuilder, ParaHeaderSproofBuilderItem},

67

    tp_traits::{ContainerChainBlockInfo, SlotFrequency},

68

};

69

70

mod common;

71

72

const UNIT: Balance = 1_000_000_000_000_000_000;

73

74

#[test]

75

1

fn genesis_balances() {

76

1

    ExtBuilder::default()

77

1

        .with_balances(vec![

78

1

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

79

1

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

80

1

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

81

1

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

82

1

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

83

1

])

84

1

        .with_collators(vec![

85

1

            // Remove ALICE and BOB from collators

86

1

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

87

1

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

88

1

])

89

1

        .build()

90

1

        .execute_with(|| {

91

1

            assert_eq!(

92

1

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

93

1

                210_000 * UNIT,

94

1

);

95

1

            assert_eq!(

96

1

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

97

1

                100_000 * UNIT,

98

1

);

99

1

});

100

1

101

102

#[test]

103

1

fn genesis_para_registrar() {

104

1

    ExtBuilder::default()

105

1

        .with_para_ids(vec![

106

1

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

107

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

108

1

])

109

1

        .build()

110

1

        .execute_with(|| {

111

1

            assert_eq!(

112

1

                Registrar::registered_para_ids(),

113

1

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

114

1

);

115

1

});

116

1

117

118

#[test]

119

1

fn genesis_para_registrar_deregister() {

120

1

    ExtBuilder::default()

121

1

        .with_para_ids(vec![

122

1

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

123

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

124

1

])

125

1

        .build()

126

1

        .execute_with(|| {

127

1

            assert_eq!(

128

1

                Registrar::registered_para_ids(),

129

1

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

130

1

);

131

132

1

            run_to_block(2);

133

1

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

134

135

            // Pending

136

1

            assert_eq!(

137

1

                Registrar::pending_registered_para_ids(),

138

1

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

139

1

);

140

141

1

            run_to_session(1);

142

1

            assert_eq!(

143

1

                Registrar::pending_registered_para_ids(),

144

1

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

145

1

);

146

1

            assert_eq!(

147

1

                Registrar::registered_para_ids(),

148

1

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

149

1

);

150

151

1

            run_to_session(2);

152

1

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

153

1

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

154

1

});

155

1

156

157

#[test]

158

1

fn genesis_para_registrar_runtime_api() {

159

1

    ExtBuilder::default()

160

1

        .with_para_ids(vec![

161

1

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

162

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

163

1

])

164

1

        .build()

165

1

        .execute_with(|| {

166

1

            assert_eq!(

167

1

                Registrar::registered_para_ids(),

168

1

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

169

1

);

170

1

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

171

172

1

            run_to_block(2);

173

1

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

174

1

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

175

176

1

            run_to_session(1);

177

1

            assert_eq!(

178

1

                Registrar::registered_para_ids(),

179

1

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

180

1

);

181

1

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

182

183

1

            run_to_session(2);

184

1

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

185

1

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

186

1

});

187

1

188

189

#[test]

190

1

fn genesis_para_registrar_container_chain_genesis_data_runtime_api() {

191

1

    let genesis_data_1001 = empty_genesis_data();

192

1

    let genesis_data_1002 = ContainerChainGenesisData {

193

1

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

194

1

        name: Default::default(),

195

1

        id: Default::default(),

196

1

        fork_id: Default::default(),

197

1

        extensions: vec![],

198

1

        properties: Default::default(),

199

1

};

200

1

    ExtBuilder::default()

201

1

        .with_para_ids(vec![

202

1

            (1001, genesis_data_1001.clone(), u32::MAX, u32::MAX).into(),

203

1

            (1002, genesis_data_1002.clone(), u32::MAX, u32::MAX).into(),

204

1

])

205

1

        .build()

206

1

        .execute_with(|| {

207

1

            assert_eq!(

208

1

                Registrar::registered_para_ids(),

209

1

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

210

1

);

211

1

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

212

213

1

            assert_eq!(

214

1

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

215

1

                Some(&genesis_data_1001)

216

1

);

217

1

            assert_eq!(

218

1

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

219

1

                Some(&genesis_data_1002)

220

1

);

221

1

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

222

223

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

224

            // with id 100

225

            // TODO: where is that 100 defined?

226

1

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

227

228

1

            run_to_block(2);

229

1

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

230

231

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

232

233

1

            let genesis_data_1003 = ContainerChainGenesisData {

234

1

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

235

1

                name: Default::default(),

236

1

                id: Default::default(),

237

1

                fork_id: Default::default(),

238

1

                extensions: vec![],

239

1

                properties: Default::default(),

240

1

};

241

1

            assert_ok!(

242

1

                Registrar::register(

243

1

                    origin_of(ALICE.into()),

244

1

                    1003.into(),

245

1

                    genesis_data_1003.clone()

246

1

),

247

1

()

248

1

);

249

250

            // Registered container chains are inserted immediately

251

1

            assert_eq!(

252

1

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

253

1

                Some(&genesis_data_1003)

254

1

);

255

256

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

257

1

            run_to_session(2u32);

258

1

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

259

1

});

260

1

261

262

#[test]

263

1

fn test_author_collation_aura() {

264

1

    ExtBuilder::default()

265

1

        .with_para_ids(vec![

266

1

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

267

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

268

1

])

269

1

        .build()

270

1

        .execute_with(|| {

271

1

            run_to_block(5);

272

1

            // Assert current slot gets updated

273

1

            assert_eq!(current_slot(), 4u64);

274

            // slot 4, alice

275

1

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

276

277

1

            run_to_block(6);

278

1

279

1

            assert_eq!(current_slot(), 5u64);

280

            // slot 5, bob

281

1

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

282

1

});

283

1

284

285

#[test]

286

1

fn test_author_collation_aura_change_of_authorities_on_session() {

287

1

    ExtBuilder::default()

288

1

        .with_balances(vec![

289

1

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

290

1

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

291

1

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

292

1

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

293

1

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

294

1

])

295

1

        .with_para_ids(vec![

296

1

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

297

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

298

1

])

299

1

        .build()

300

1

        .execute_with(|| {

301

1

            run_to_block(2);

302

1

            // Assert current slot gets updated

303

1

            assert_eq!(current_slot(), 1u64);

304

1

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

305

306

            // We change invulnerables

307

            // We first need to set the keys

308

1

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

309

1

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

310

1

311

1

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

312

1

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

313

1

314

1

            // Set CHARLIE and DAVE keys

315

1

            assert_ok!(Session::set_keys(

316

1

                origin_of(CHARLIE.into()),

317

1

                dancebox_runtime::SessionKeys {

318

1

                    nimbus: charlie_id.clone(),

319

1

},

320

1

                vec![]

321

1

));

322

1

            assert_ok!(Session::set_keys(

323

1

                origin_of(DAVE.into()),

324

1

                dancebox_runtime::SessionKeys {

325

1

                    nimbus: dave_id.clone(),

326

1

},

327

1

                vec![]

328

1

));

329

330

            // Change invulnerables

331

1

            assert_ok!(Invulnerables::remove_invulnerable(

332

1

                root_origin(),

333

1

                ALICE.into()

334

1

));

335

1

            assert_ok!(Invulnerables::remove_invulnerable(

336

1

                root_origin(),

337

1

                BOB.into()

338

1

));

339

1

            assert_ok!(Invulnerables::add_invulnerable(

340

1

                root_origin(),

341

1

                CHARLIE.into()

342

1

));

343

1

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

344

345

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

346

1

            run_to_session(1u32);

347

1

            let author = get_orchestrator_current_author().unwrap();

348

1

349

1

            assert_eq!(current_author(), author);

350

1

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

351

352

            // Invulnerables should have triggered on new session authorities change

353

1

            run_to_session(2u32);

354

1

            let author_after_changes = get_orchestrator_current_author().unwrap();

355

1

356

1

            assert_eq!(current_author(), author_after_changes);

357

1

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

358

1

});

359

1

360

361

#[test]

362

1

fn test_author_collation_aura_add_assigned_to_paras() {

363

1

    ExtBuilder::default()

364

1

        .with_balances(vec![

365

1

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

366

1

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

367

1

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

368

1

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

369

1

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

370

1

])

371

1

        .with_para_ids(vec![

372

1

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

373

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

374

1

])

375

1

        .build()

376

1

        .execute_with(|| {

377

1

            run_to_block(2);

378

1

            // Assert current slot gets updated

379

1

            assert_eq!(current_slot(), 1u64);

380

1

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

381

382

            // We change invulnerables

383

            // We first need to set the keys

384

1

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

385

1

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

386

1

387

1

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

388

1

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

389

1

390

1

            // Set CHARLIE and DAVE keys

391

1

            assert_ok!(Session::set_keys(

392

1

                origin_of(CHARLIE.into()),

393

1

                dancebox_runtime::SessionKeys { nimbus: charlie_id },

394

1

                vec![]

395

1

));

396

1

            assert_ok!(Session::set_keys(

397

1

                origin_of(DAVE.into()),

398

1

                dancebox_runtime::SessionKeys { nimbus: dave_id },

399

1

                vec![]

400

1

));

401

402

            // Add new invulnerables

403

1

            assert_ok!(Invulnerables::add_invulnerable(

404

1

                root_origin(),

405

1

                CHARLIE.into()

406

1

));

407

1

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

408

409

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

410

1

            run_to_session(1u32);

411

1

            let author = get_orchestrator_current_author().unwrap();

412

1

413

1

            assert_eq!(current_author(), author);

414

1

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

415

416

            // Invulnerables should have triggered on new session authorities change

417

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

418

1

            run_to_session(2u32);

419

1

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

420

1

            let assignment = CollatorAssignment::collator_container_chain();

421

1

            assert_eq!(

422

1

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

423

1

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

424

1

);

425

1

});

426

1

427

428

#[test]

429

1

fn test_authors_without_paras() {

430

1

    ExtBuilder::default()

431

1

        .with_balances(vec![

432

1

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

433

1

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

434

1

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

435

1

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

436

1

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

437

1

])

438

1

        .with_collators(vec![

439

1

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

440

1

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

441

1

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

442

1

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

443

1

])

444

1

        .build()

445

1

        .execute_with(|| {

446

1

            run_to_block(2);

447

1

            // Assert current slot gets updated

448

1

            assert_eq!(current_slot(), 1u64);

449

1

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

450

451

            // Only Alice and Bob collate for our chain

452

1

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

453

1

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

454

1

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

455

1

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

456

1

457

1

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

458

1

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

459

460

            // Set moondance collators to min 2 max 5

461

1

            assert_ok!(

462

1

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

463

1

()

464

1

);

465

1

            assert_ok!(

466

1

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

467

1

()

468

1

);

469

470

1

            run_to_session(2);

471

1

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

472

1

});

473

1

474

475

#[test]

476

1

fn test_authors_paras_inserted_a_posteriori() {

477

1

    ExtBuilder::default()

478

1

        .with_balances(vec![

479

1

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

480

1

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

481

1

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

482

1

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

483

1

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

484

1

])

485

1

        .with_collators(vec![

486

1

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

487

1

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

488

1

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

489

1

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

490

1

])

491

1

        .build()

492

1

        .execute_with(|| {

493

1

            run_to_block(2);

494

1

            // Assert current slot gets updated

495

1

            assert_eq!(current_slot(), 1u64);

496

1

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

497

498

            // Alice and Bob collate in our chain

499

1

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

500

1

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

501

1

502

1

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

503

504

1

            assert_ok!(Registrar::register(

505

1

                origin_of(ALICE.into()),

506

1

                1001.into(),

507

1

                empty_genesis_data()

508

1

));

509

1

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

510

1

            assert_ok!(Registrar::mark_valid_for_collating(

511

1

                root_origin(),

512

1

                1001.into()

513

1

));

514

1

            assert_ok!(ServicesPayment::purchase_credits(

515

1

                origin_of(ALICE.into()),

516

1

                1001.into(),

517

1

                block_credits_to_required_balance(1000, 1001.into())

518

1

));

519

1

            assert_ok!(Registrar::register(

520

1

                origin_of(ALICE.into()),

521

1

                1002.into(),

522

1

                empty_genesis_data()

523

1

));

524

1

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

525

1

            assert_ok!(Registrar::mark_valid_for_collating(

526

1

                root_origin(),

527

1

                1002.into()

528

1

));

529

1

            assert_ok!(ServicesPayment::purchase_credits(

530

1

                origin_of(ALICE.into()),

531

1

                1002.into(),

532

1

                block_credits_to_required_balance(1000, 1002.into())

533

1

));

534

535

            // Assignment should happen after 2 sessions

536

1

            run_to_session(1u32);

537

1

            let assignment = CollatorAssignment::collator_container_chain();

538

1

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

539

1

            run_to_session(2u32);

540

1

541

1

            // Charlie and Dave should be assigned to para 1001

542

1

            let assignment = CollatorAssignment::collator_container_chain();

543

1

            assert_eq!(

544

1

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

545

1

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

546

1

);

547

1

});

548

1

549

550

#[test]

551

1

fn test_authors_paras_inserted_a_posteriori_with_collators_already_assigned() {

552

1

    ExtBuilder::default()

553

1

        .with_balances(vec![

554

1

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

555

1

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

556

1

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

557

1

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

558

1

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

559

1

])

560

1

        .with_collators(vec![

561

1

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

562

1

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

563

1

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

564

1

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

565

1

])

566

1

        .with_config(pallet_configuration::HostConfiguration {

567

1

            max_collators: 100,

568

1

            min_orchestrator_collators: 2,

569

1

            max_orchestrator_collators: 5,

570

1

            collators_per_container: 2,

571

1

            full_rotation_period: 24,

572

1

            ..Default::default()

573

1

})

574

1

        .build()

575

1

        .execute_with(|| {

576

1

            run_to_block(2);

577

1

            // Assert current slot gets updated

578

1

            assert_eq!(current_slot(), 1u64);

579

1

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

580

581

            // Alice and Bob collate in our chain

582

1

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

583

1

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

584

1

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

585

1

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

586

1

587

1

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

588

589

1

            assert_ok!(Registrar::register(

590

1

                origin_of(ALICE.into()),

591

1

                1001.into(),

592

1

                empty_genesis_data()

593

1

));

594

1

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

595

1

            assert_ok!(Registrar::mark_valid_for_collating(

596

1

                root_origin(),

597

1

                1001.into()

598

1

));

599

1

            assert_ok!(ServicesPayment::purchase_credits(

600

1

                origin_of(ALICE.into()),

601

1

                1001.into(),

602

1

                block_credits_to_required_balance(1000, 1001.into())

603

1

));

604

605

            // Assignment should happen after 2 sessions

606

1

            run_to_session(1u32);

607

1

            let assignment = CollatorAssignment::collator_container_chain();

608

1

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

609

1

            run_to_session(2u32);

610

1

611

1

            // Charlie and Dave are now assigned to para 1001

612

1

            let assignment = CollatorAssignment::collator_container_chain();

613

1

            assert_eq!(

614

1

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

615

1

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

616

1

);

617

1

            assert_eq!(

618

1

                assignment.orchestrator_chain,

619

1

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

620

1

);

621

1

});

622

1

623

624

#[test]

625

1

fn test_paras_registered_but_zero_credits() {

626

1

    ExtBuilder::default()

627

1

        .with_balances(vec![

628

1

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

629

1

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

630

1

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

631

1

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

632

1

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

633

1

])

634

1

        .with_collators(vec![

635

1

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

636

1

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

637

1

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

638

1

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

639

1

])

640

1

        .build()

641

1

        .execute_with(|| {

642

1

            run_to_block(2);

643

1

            // Assert current slot gets updated

644

1

            assert_eq!(current_slot(), 1u64);

645

1

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

646

647

            // Alice and Bob collate in our chain

648

1

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

649

1

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

650

1

651

1

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

652

653

1

            assert_ok!(Registrar::register(

654

1

                origin_of(ALICE.into()),

655

1

                1001.into(),

656

1

                empty_genesis_data()

657

1

));

658

1

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

659

1

            assert_ok!(Registrar::mark_valid_for_collating(

660

1

                root_origin(),

661

1

                1001.into()

662

1

));

663

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

664

1

            assert_ok!(ServicesPayment::set_block_production_credits(

665

1

                root_origin(),

666

1

                1001.into(),

667

1

668

1

));

669

670

            // Assignment should happen after 2 sessions

671

1

            run_to_session(1u32);

672

1

            let assignment = CollatorAssignment::collator_container_chain();

673

1

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

674

1

            run_to_session(2u32);

675

1

676

1

            // Nobody should be assigned to para 1001

677

1

            let assignment = CollatorAssignment::collator_container_chain();

678

1

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

679

1

});

680

1

681

682

#[test]

683

1

fn test_paras_registered_but_not_enough_credits() {

684

1

    ExtBuilder::default()

685

1

        .with_balances(vec![

686

1

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

687

1

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

688

1

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

689

1

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

690

1

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

691

1

])

692

1

        .with_collators(vec![

693

1

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

694

1

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

695

1

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

696

1

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

697

1

])

698

1

        .build()

699

1

        .execute_with(|| {

700

1

            run_to_block(2);

701

1

            // Assert current slot gets updated

702

1

            assert_eq!(current_slot(), 1u64);

703

1

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

704

705

            // Alice and Bob collate in our chain

706

1

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

707

1

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

708

1

709

1

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

710

711

1

            assert_ok!(Registrar::register(

712

1

                origin_of(ALICE.into()),

713

1

                1001.into(),

714

1

                empty_genesis_data()

715

1

));

716

1

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

717

1

            assert_ok!(Registrar::mark_valid_for_collating(

718

1

                root_origin(),

719

1

                1001.into()

720

1

));

721

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

722

1

            assert_ok!(ServicesPayment::set_block_production_credits(

723

1

                root_origin(),

724

1

                1001.into(),

725

1

726

1

));

727

            // Purchase 1 credit less that what is needed

728

1

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

729

1

            assert_ok!(ServicesPayment::set_block_production_credits(

730

1

                root_origin(),

731

1

                1001.into(),

732

1

                credits_1001

733

1

));

734

735

            // Assignment should happen after 2 sessions

736

1

            run_to_session(1u32);

737

1

            let assignment = CollatorAssignment::collator_container_chain();

738

1

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

739

1

            run_to_session(2u32);

740

1

            // Nobody should be assigned to para 1001

741

1

            let assignment = CollatorAssignment::collator_container_chain();

742

1

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

743

744

            // Now purchase the missing block credit

745

1

            assert_ok!(ServicesPayment::set_block_production_credits(

746

1

                root_origin(),

747

1

                1001.into(),

748

1

                credits_1001 + 1

749

1

));

750

751

1

            run_to_session(4u32);

752

1

            // Charlie and Dave should be assigned to para 1001

753

1

            let assignment = CollatorAssignment::collator_container_chain();

754

1

            assert_eq!(

755

1

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

756

1

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

757

1

);

758

1

});

759

1

760

761

#[test]

762

1

fn test_paras_registered_but_only_credits_for_1_session() {

763

1

    ExtBuilder::default()

764

1

        .with_balances(vec![

765

1

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

766

1

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

767

1

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

768

1

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

769

1

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

770

1

])

771

1

        .with_collators(vec![

772

1

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

773

1

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

774

1

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

775

1

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

776

1

])

777

1

        .build()

778

1

        .execute_with(|| {

779

1

            run_to_block(2);

780

1

            // Assert current slot gets updated

781

1

            assert_eq!(current_slot(), 1u64);

782

1

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

783

784

            // Alice and Bob collate in our chain

785

1

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

786

1

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

787

1

788

1

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

789

790

1

            assert_ok!(Registrar::register(

791

1

                origin_of(ALICE.into()),

792

1

                1001.into(),

793

1

                empty_genesis_data()

794

1

));

795

1

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

796

1

            assert_ok!(Registrar::mark_valid_for_collating(

797

1

                root_origin(),

798

1

                1001.into()

799

1

));

800

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

801

1

            assert_ok!(ServicesPayment::set_block_production_credits(

802

1

                root_origin(),

803

1

                1001.into(),

804

1

805

1

));

806

            // Purchase only enough credits for 1 session

807

1

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

808

1

            assert_ok!(ServicesPayment::set_block_production_credits(

809

1

                root_origin(),

810

1

                1001.into(),

811

1

                credits_1001

812

1

));

813

814

            // Assignment should happen after 2 sessions

815

1

            run_to_session(1u32);

816

1

            let assignment = CollatorAssignment::collator_container_chain();

817

1

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

818

1

            run_to_session(2u32);

819

1

            // Charlie and Dave should be assigned to para 1001

820

1

            let assignment = CollatorAssignment::collator_container_chain();

821

1

            assert_eq!(

822

1

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

823

1

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

824

1

);

825

826

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

827

1

            run_block();

828

1

            let credits =

829

1

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

830

1

                    .unwrap_or_default();

831

1

            assert_eq!(credits, credits_1001);

832

833

            // Simulate block inclusion from container chain 1001

834

1

            let mut sproof = ParaHeaderSproofBuilder::default();

835

1

            let slot: u64 = 5;

836

1

            let s = ParaHeaderSproofBuilderItem {

837

1

                para_id: 1001.into(),

838

1

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

839

1

                    parent_hash: Default::default(),

840

1

                    number: 1,

841

1

                    state_root: Default::default(),

842

1

                    extrinsics_root: Default::default(),

843

1

                    digest: sp_runtime::generic::Digest {

844

1

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

845

1

},

846

1

}),

847

1

};

848

1

            sproof.items.push(s);

849

1

            set_author_noting_inherent_data(sproof);

850

1

851

1

            run_block();

852

1

            let credits =

853

1

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

854

1

                    .unwrap_or_default();

855

1

            assert_eq!(credits, credits_1001 - 1);

856

857

1

            run_to_session(4u32);

858

1

            // Nobody should be assigned to para 1001

859

1

            let assignment = CollatorAssignment::collator_container_chain();

860

1

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

861

862

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

863

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

864

1

            let credits =

865

1

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

866

1

                    .unwrap_or_default();

867

1

            assert_eq!(credits, credits_1001 - 1);

868

1

});

869

1

870

871

#[test]

872

1

fn test_parachains_deregister_collators_re_assigned() {

873

1

    ExtBuilder::default()

874

1

        .with_balances(vec![

875

1

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

876

1

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

877

1

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

878

1

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

879

1

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

880

1

])

881

1

        .with_collators(vec![

882

1

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

883

1

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

884

1

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

885

1

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

886

1

])

887

1

        .with_para_ids(vec![

888

1

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

889

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

890

1

])

891

1

        .build()

892

1

        .execute_with(|| {

893

1

            run_to_block(2);

894

1

            // Assert current slot gets updated

895

1

            assert_eq!(current_slot(), 1u64);

896

1

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

897

898

            // Alice and Bob are authorities

899

1

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

900

1

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

901

1

902

1

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

903

904

            // Charlie and Dave to 1001

905

1

            let assignment = CollatorAssignment::collator_container_chain();

906

1

            assert_eq!(

907

1

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

908

1

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

909

1

);

910

911

1

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

912

913

            // Assignment should happen after 2 sessions

914

1

            run_to_session(1u32);

915

1

916

1

            let assignment = CollatorAssignment::collator_container_chain();

917

1

            assert_eq!(

918

1

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

919

1

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

920

1

);

921

922

1

            run_to_session(2u32);

923

1

924

1

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

925

1

            let assignment = CollatorAssignment::collator_container_chain();

926

1

            assert_eq!(

927

1

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

928

1

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

929

1

);

930

1

});

931

1

932

933

#[test]

934

1

fn test_parachains_deregister_collators_config_change_reassigned() {

935

1

    ExtBuilder::default()

936

1

        .with_balances(vec![

937

1

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

938

1

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

939

1

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

940

1

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

941

1

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

942

1

])

943

1

        .with_collators(vec![

944

1

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

945

1

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

946

1

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

947

1

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

948

1

])

949

1

        .with_para_ids(vec![

950

1

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

951

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

952

1

])

953

1

        .build()

954

1

        .execute_with(|| {

955

1

            run_to_block(2);

956

1

            // Assert current slot gets updated

957

1

            assert_eq!(current_slot(), 1u64);

958

1

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

959

960

            // Alice and Bob are authorities

961

1

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

962

1

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

963

1

964

1

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

965

966

            // Set orchestrator collators to 1

967

1

            assert_ok!(

968

1

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

969

1

()

970

1

);

971

972

            // Set container chain collators to 3

973

1

            assert_ok!(

974

1

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

975

1

()

976

1

);

977

978

            // Charlie and Dave to 1001

979

1

            let assignment = CollatorAssignment::collator_container_chain();

980

1

            assert_eq!(

981

1

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

982

1

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

983

1

);

984

985

            // Assignment should happen after 2 sessions

986

1

            run_to_session(1u32);

987

1

988

1

            let assignment = CollatorAssignment::collator_container_chain();

989

1

            assert_eq!(

990

1

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

991

1

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

992

1

);

993

994

1

            run_to_session(2u32);

995

1

996

1

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

997

1

            let assignment = CollatorAssignment::collator_container_chain();

998

1

            assert_eq!(

999

1

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

1000

1

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

1001

1

);

1002

1003

1

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

1004

1

});

1005

1

1006

1007

#[test]

1008

1

fn test_orchestrator_collators_with_non_sufficient_collators() {

1009

1

    ExtBuilder::default()

1010

1

        .with_balances(vec![

1011

1

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

1012

1

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

1013

1

])

1014

1

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

1015

1

        .with_para_ids(vec![

1016

1

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

1017

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1018

1

])

1019

1

        .build()

1020

1

        .execute_with(|| {

1021

1

            run_to_block(2);

1022

1

            // Assert current slot gets updated

1023

1

            assert_eq!(current_slot(), 1u64);

1024

1

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

1025

1026

            // Alice and Bob are authorities

1027

1

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

1028

1

1029

1

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

1030

1

});

1031

1

1032

1033

#[test]

1034

1

fn test_configuration_on_session_change() {

1035

1

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

1036

1

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

1037

1

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

1038

1

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

1039

1040

1

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

1041

1

        run_to_session(1u32);

1042

1

1043

1

        assert_ok!(

1044

1

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

1045

1

()

1046

1

);

1047

1

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

1048

1

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

1049

1

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

1050

1051

1

        run_to_session(2u32);

1052

1

        assert_ok!(

1053

1

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

1054

1

()

1055

1

);

1056

1

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

1057

1

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

1058

1

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

1059

1060

1

        run_to_session(3u32);

1061

1

1062

1

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

1063

1

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

1064

1

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

1065

1066

1

        run_to_session(4u32);

1067

1

1068

1

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

1069

1

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

1070

1

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

1071

1

});

1072

1

1073

1074

#[test]

1075

1

fn test_author_collation_aura_add_assigned_to_paras_runtime_api() {

1076

1

    ExtBuilder::default()

1077

1

        .with_balances(vec![

1078

1

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

1079

1

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

1080

1

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

1081

1

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

1082

1

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

1083

1

])

1084

1

        .with_para_ids(vec![

1085

1

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

1086

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1087

1

])

1088

1

        .build()

1089

1

        .execute_with(|| {

1090

1

            run_to_block(2);

1091

1

            // Assert current slot gets updated

1092

1

            assert_eq!(current_slot(), 1u64);

1093

1

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

1094

1

            assert_eq!(

1095

1

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

1096

1

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

1097

1

);

1098

1

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

1099

1

            assert_eq!(

1100

1

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

1101

1

                Some(100.into())

1102

1

);

1103

1

            assert_eq!(

1104

1

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

1105

1

                Some(100.into())

1106

1

);

1107

1

            assert_eq!(

1108

1

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

1109

1

                None

1110

1

);

1111

1

            assert_eq!(

1112

1

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

1113

1

                None

1114

1

);

1115

1116

            // We change invulnerables

1117

            // We first need to set the keys

1118

1

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

1119

1

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

1120

1

1121

1

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

1122

1

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

1123

1

1124

1

            // Set CHARLIE and DAVE keys

1125

1

            assert_ok!(Session::set_keys(

1126

1

                origin_of(CHARLIE.into()),

1127

1

                dancebox_runtime::SessionKeys { nimbus: charlie_id },

1128

1

                vec![]

1129

1

));

1130

1

            assert_ok!(Session::set_keys(

1131

1

                origin_of(DAVE.into()),

1132

1

                dancebox_runtime::SessionKeys { nimbus: dave_id },

1133

1

                vec![]

1134

1

));

1135

1136

            // Set new invulnerables

1137

1

            assert_ok!(Invulnerables::add_invulnerable(

1138

1

                root_origin(),

1139

1

                CHARLIE.into()

1140

1

));

1141

1

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

1142

1143

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

1144

1

            run_to_session(1u32);

1145

1

            let author = get_orchestrator_current_author().unwrap();

1146

1

1147

1

            assert_eq!(current_author(), author);

1148

1

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

1149

1

            assert_eq!(

1150

1

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

1151

1

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

1152

1

);

1153

1

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

1154

1

            assert_eq!(

1155

1

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

1156

1

                None

1157

1

);

1158

1

            assert_eq!(

1159

1

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

1160

1

                Some(1001.into())

1161

1

);

1162

1163

            // Invulnerables should have triggered on new session authorities change

1164

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

1165

1

            run_to_session(2u32);

1166

1

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

1167

1

            let assignment = CollatorAssignment::collator_container_chain();

1168

1

            assert_eq!(

1169

1

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

1170

1

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

1171

1

);

1172

1173

1

            assert_eq!(

1174

1

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

1175

1

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

1176

1

);

1177

1

            assert_eq!(

1178

1

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

1179

1

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

1180

1

);

1181

1

            assert_eq!(

1182

1

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

1183

1

                Some(1001.into())

1184

1

);

1185

1

            assert_eq!(

1186

1

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

1187

1

                Some(1001.into())

1188

1

);

1189

1190

            // Remove BOB

1191

1

            assert_ok!(Invulnerables::remove_invulnerable(

1192

1

                root_origin(),

1193

1

                BOB.into()

1194

1

));

1195

1196

1

            run_to_session(3u32);

1197

1

            assert_eq!(

1198

1

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

1199

1

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

1200

1

);

1201

1

            assert_eq!(

1202

1

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

1203

1

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

1204

1

);

1205

1

            assert_eq!(

1206

1

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

1207

1

                Some(100.into())

1208

1

);

1209

1

            assert_eq!(

1210

1

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

1211

1

                None

1212

1

);

1213

1214

1

            run_to_session(4u32);

1215

1

            assert_eq!(

1216

1

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

1217

1

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

1218

1

);

1219

1

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

1220

1

            assert_eq!(

1221

1

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

1222

1

                None

1223

1

);

1224

1

            assert_eq!(

1225

1

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

1226

1

                None

1227

1

);

1228

1

});

1229

1

1230

1231

#[test]

1232

1

fn test_consensus_runtime_api() {

1233

1

    ExtBuilder::default()

1234

1

        .with_balances(vec![

1235

1

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

1236

1

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

1237

1

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

1238

1

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

1239

1

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

1240

1

])

1241

1

        .with_para_ids(vec![

1242

1

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

1243

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1244

1

])

1245

1

        .build()

1246

1

        .execute_with(|| {

1247

1

            run_to_block(2);

1248

1

1249

1

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

1250

1

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

1251

1

1252

1

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

1253

1

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

1254

1

1255

1

            assert_eq!(

1256

1

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

1257

1

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

1258

1

);

1259

1

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

1260

1

            assert_eq!(

1261

1

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

1262

1

                Some(100.into())

1263

1

);

1264

1

            assert_eq!(

1265

1

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

1266

1

                Some(100.into())

1267

1

);

1268

1

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

1269

1

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

1270

1271

            // Set CHARLIE and DAVE keys

1272

1

            assert_ok!(Session::set_keys(

1273

1

                origin_of(CHARLIE.into()),

1274

1

                dancebox_runtime::SessionKeys {

1275

1

                    nimbus: charlie_id.clone(),

1276

1

},

1277

1

                vec![]

1278

1

));

1279

1

            assert_ok!(Session::set_keys(

1280

1

                origin_of(DAVE.into()),

1281

1

                dancebox_runtime::SessionKeys {

1282

1

                    nimbus: dave_id.clone(),

1283

1

},

1284

1

                vec![]

1285

1

));

1286

1287

            // Set new invulnerables

1288

1

            assert_ok!(Invulnerables::add_invulnerable(

1289

1

                root_origin(),

1290

1

                CHARLIE.into()

1291

1

));

1292

1

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

1293

1294

1

            run_to_session(2u32);

1295

1

            assert_eq!(

1296

1

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

1297

1

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

1298

1

);

1299

1

            assert_eq!(

1300

1

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

1301

1

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

1302

1

);

1303

1

            assert_eq!(

1304

1

                Runtime::check_para_id_assignment(alice_id),

1305

1

                Some(100.into())

1306

1

);

1307

1

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

1308

1

            assert_eq!(

1309

1

                Runtime::check_para_id_assignment(charlie_id),

1310

1

                Some(1001.into())

1311

1

);

1312

1

            assert_eq!(

1313

1

                Runtime::check_para_id_assignment(dave_id),

1314

1

                Some(1001.into())

1315

1

);

1316

1

});

1317

1

1318

1319

#[test]

1320

1

fn test_consensus_runtime_api_session_changes() {

1321

1

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

1322

1

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

1323

1

    // if we can predict correctly

1324

1

    ExtBuilder::default()

1325

1

        .with_balances(vec![

1326

1

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

1327

1

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

1328

1

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

1329

1

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

1330

1

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

1331

1

])

1332

1

        .with_para_ids(vec![

1333

1

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

1334

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1335

1

])

1336

1

        .build()

1337

1

        .execute_with(|| {

1338

1

            run_to_block(2);

1339

1

1340

1

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

1341

1

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

1342

1

1343

1

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

1344

1

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

1345

1

1346

1

            assert_eq!(

1347

1

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

1348

1

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

1349

1

);

1350

1

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

1351

1

            assert_eq!(

1352

1

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

1353

1

                Some(100.into())

1354

1

);

1355

1

            assert_eq!(

1356

1

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

1357

1

                Some(100.into())

1358

1

);

1359

1

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

1360

1

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

1361

1362

            // Set CHARLIE and DAVE keys

1363

1

            assert_ok!(Session::set_keys(

1364

1

                origin_of(CHARLIE.into()),

1365

1

                dancebox_runtime::SessionKeys {

1366

1

                    nimbus: charlie_id.clone(),

1367

1

},

1368

1

                vec![]

1369

1

));

1370

1

            assert_ok!(Session::set_keys(

1371

1

                origin_of(DAVE.into()),

1372

1

                dancebox_runtime::SessionKeys {

1373

1

                    nimbus: dave_id.clone(),

1374

1

},

1375

1

                vec![]

1376

1

));

1377

1378

            // Set new invulnerables

1379

1

            assert_ok!(Invulnerables::add_invulnerable(

1380

1

                root_origin(),

1381

1

                CHARLIE.into()

1382

1

));

1383

1

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

1384

1385

1

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

1386

1

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

1387

1

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

1388

1

            // edge of a session change

1389

1

            run_to_block(session_two_edge - 2);

1390

1

1391

1

            assert_eq!(

1392

1

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

1393

1

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

1394

1

);

1395

1

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

1396

1

            assert_eq!(

1397

1

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

1398

1

                Some(100.into())

1399

1

);

1400

1

            assert_eq!(

1401

1

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

1402

1

                Some(100.into())

1403

1

);

1404

1

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

1405

1

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

1406

1407

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

1408

            // authorities of the next block!

1409

1

            run_to_block(session_two_edge - 1);

1410

1

            assert_eq!(

1411

1

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

1412

1

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

1413

1

);

1414

1

            assert_eq!(

1415

1

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

1416

1

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

1417

1

);

1418

1

            assert_eq!(

1419

1

                Runtime::check_para_id_assignment(alice_id),

1420

1

                Some(100.into())

1421

1

);

1422

1

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

1423

1

            assert_eq!(

1424

1

                Runtime::check_para_id_assignment(charlie_id),

1425

1

                Some(1001.into())

1426

1

);

1427

1

            assert_eq!(

1428

1

                Runtime::check_para_id_assignment(dave_id),

1429

1

                Some(1001.into())

1430

1

);

1431

1

});

1432

1

1433

1434

#[test]

1435

1

fn test_consensus_runtime_api_next_session() {

1436

1

    ExtBuilder::default()

1437

1

        .with_balances(vec![

1438

1

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

1439

1

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

1440

1

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

1441

1

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

1442

1

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

1443

1

])

1444

1

        .with_para_ids(vec![

1445

1

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

1446

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1447

1

])

1448

1

        .build()

1449

1

        .execute_with(|| {

1450

1

            run_to_block(2);

1451

1

1452

1

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

1453

1

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

1454

1

1455

1

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

1456

1

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

1457

1

1458

1

            assert_eq!(

1459

1

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

1460

1

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

1461

1

);

1462

1

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

1463

1

            assert_eq!(

1464

1

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

1465

1

                Some(100.into())

1466

1

);

1467

1

            assert_eq!(

1468

1

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

1469

1

                Some(100.into())

1470

1

);

1471

1

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

1472

1

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

1473

1474

            // In the next session the assignment will not change

1475

1

            assert_eq!(

1476

1

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

1477

1

                Some(100.into())

1478

1

);

1479

1

            assert_eq!(

1480

1

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

1481

1

                Some(100.into())

1482

1

);

1483

1

            assert_eq!(

1484

1

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

1485

1

                None,

1486

1

);

1487

1

            assert_eq!(

1488

1

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

1489

1

                None,

1490

1

);

1491

1492

            // Set CHARLIE and DAVE keys

1493

1

            assert_ok!(Session::set_keys(

1494

1

                origin_of(CHARLIE.into()),

1495

1

                dancebox_runtime::SessionKeys {

1496

1

                    nimbus: charlie_id.clone(),

1497

1

},

1498

1

                vec![]

1499

1

));

1500

1

            assert_ok!(Session::set_keys(

1501

1

                origin_of(DAVE.into()),

1502

1

                dancebox_runtime::SessionKeys {

1503

1

                    nimbus: dave_id.clone(),

1504

1

},

1505

1

                vec![]

1506

1

));

1507

1508

            // Set new invulnerables

1509

1

            assert_ok!(Invulnerables::add_invulnerable(

1510

1

                root_origin(),

1511

1

                CHARLIE.into()

1512

1

));

1513

1

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

1514

1515

1

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

1516

1

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

1517

1

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

1518

1

            // edge of a session change

1519

1

            run_to_block(session_two_edge - 2);

1520

1

1521

1

            assert_eq!(

1522

1

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

1523

1

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

1524

1

);

1525

1

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

1526

1

            assert_eq!(

1527

1

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

1528

1

                Some(100.into())

1529

1

);

1530

1

            assert_eq!(

1531

1

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

1532

1

                Some(100.into())

1533

1

);

1534

1

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

1535

1

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

1536

1537

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

1538

1

            assert_eq!(

1539

1

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

1540

1

                Some(100.into())

1541

1

);

1542

1

            assert_eq!(

1543

1

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

1544

1

                Some(100.into())

1545

1

);

1546

1

            assert_eq!(

1547

1

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

1548

1

                Some(1001.into()),

1549

1

);

1550

1

            assert_eq!(

1551

1

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

1552

1

                Some(1001.into()),

1553

1

);

1554

1555

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

1556

            // authorities of the next block!

1557

1

            run_to_block(session_two_edge - 1);

1558

1

            assert_eq!(

1559

1

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

1560

1

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

1561

1

);

1562

1

            assert_eq!(

1563

1

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

1564

1

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

1565

1

);

1566

1

            assert_eq!(

1567

1

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

1568

1

                Some(100.into())

1569

1

);

1570

1

            assert_eq!(

1571

1

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

1572

1

                Some(100.into())

1573

1

);

1574

1

            assert_eq!(

1575

1

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

1576

1

                Some(1001.into())

1577

1

);

1578

1

            assert_eq!(

1579

1

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

1580

1

                Some(1001.into())

1581

1

);

1582

1583

            // check_para_id_assignment_next_session returns the same value as check_para_id_assignment

1584

            // because we are on a session boundary

1585

1

            assert_eq!(

1586

1

                Runtime::check_para_id_assignment_next_session(alice_id),

1587

1

                Some(100.into())

1588

1

);

1589

1

            assert_eq!(

1590

1

                Runtime::check_para_id_assignment_next_session(bob_id),

1591

1

                Some(100.into())

1592

1

);

1593

1

            assert_eq!(

1594

1

                Runtime::check_para_id_assignment_next_session(charlie_id),

1595

1

                Some(1001.into())

1596

1

);

1597

1

            assert_eq!(

1598

1

                Runtime::check_para_id_assignment_next_session(dave_id),

1599

1

                Some(1001.into())

1600

1

);

1601

1

});

1602

1

1603

1604

#[test]

1605

1

fn test_author_noting_self_para_id_not_noting() {

1606

1

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

1607

1

        let mut sproof = ParaHeaderSproofBuilder::default();

1608

1

        let slot: u64 = 5;

1609

1

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

1610

1

        let s = ParaHeaderSproofBuilderItem {

1611

1

            para_id: self_para,

1612

1

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

1613

1

                parent_hash: Default::default(),

1614

1

                number: Default::default(),

1615

1

                state_root: Default::default(),

1616

1

                extrinsics_root: Default::default(),

1617

1

                digest: sp_runtime::generic::Digest {

1618

1

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

1619

1

},

1620

1

}),

1621

1

};

1622

1

        sproof.items.push(s);

1623

1

1624

1

        set_author_noting_inherent_data(sproof);

1625

1

1626

1

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

1627

1

});

1628

1

1629

1630

#[test]

1631

1

fn test_author_noting_not_self_para() {

1632

1

    ExtBuilder::default()

1633

1

        .with_balances(vec![

1634

1

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

1635

1

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

1636

1

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

1637

1

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

1638

1

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

1639

1

])

1640

1

        .with_collators(vec![

1641

1

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

1642

1

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

1643

1

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

1644

1

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

1645

1

])

1646

1

        .with_para_ids(vec![

1647

1

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

1648

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1649

1

])

1650

1

        .build()

1651

1

        .execute_with(|| {

1652

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1653

1

            let slot: u64 = 5;

1654

1

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

1655

1

1656

1

            // Charlie and Dave to 1001

1657

1

            let assignment = CollatorAssignment::collator_container_chain();

1658

1

            assert_eq!(

1659

1

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

1660

1

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

1661

1

);

1662

1663

1

            let s = ParaHeaderSproofBuilderItem {

1664

1

                para_id: other_para,

1665

1

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

1666

1

                    parent_hash: Default::default(),

1667

1

                    number: 1,

1668

1

                    state_root: Default::default(),

1669

1

                    extrinsics_root: Default::default(),

1670

1

                    digest: sp_runtime::generic::Digest {

1671

1

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

1672

1

},

1673

1

}),

1674

1

};

1675

1

            sproof.items.push(s);

1676

1

1677

1

            set_author_noting_inherent_data(sproof);

1678

1

1679

1

            assert_eq!(

1680

1

                AuthorNoting::latest_author(other_para),

1681

1

                Some(ContainerChainBlockInfo {

1682

1

                    block_number: 1,

1683

1

                    author: AccountId::from(DAVE),

1684

1

                    latest_slot_number: 0.into(),

1685

1

})

1686

1

);

1687

1

});

1688

1

1689

1690

#[test]

1691

1

fn test_author_noting_set_author_and_kill_author_data() {

1692

1

    ExtBuilder::default()

1693

1

        .with_balances(vec![

1694

1

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

1695

1

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

1696

1

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

1697

1

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

1698

1

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

1699

1

])

1700

1

        .with_collators(vec![

1701

1

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

1702

1

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

1703

1

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

1704

1

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

1705

1

])

1706

1

        .with_para_ids(vec![

1707

1

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

1708

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1709

1

])

1710

1

        .build()

1711

1

        .execute_with(|| {

1712

1

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

1713

1

1714

1

            assert_ok!(AuthorNoting::set_author(

1715

1

                root_origin(),

1716

1

                other_para,

1717

1

1,

1718

1

                AccountId::from(DAVE),

1719

1

                1.into()

1720

1

));

1721

1722

1

            assert_eq!(

1723

1

                AuthorNoting::latest_author(other_para),

1724

1

                Some(ContainerChainBlockInfo {

1725

1

                    block_number: 1,

1726

1

                    author: AccountId::from(DAVE),

1727

1

                    latest_slot_number: 1.into(),

1728

1

})

1729

1

);

1730

1731

1

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

1732

1733

1

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

1734

1

});

1735

1

1736

1737

#[test]

1738

1

fn test_author_noting_set_author_and_kill_author_data_bad_origin() {

1739

1

    ExtBuilder::default()

1740

1

        .with_balances(vec![

1741

1

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

1742

1

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

1743

1

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

1744

1

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

1745

1

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

1746

1

])

1747

1

        .with_collators(vec![

1748

1

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

1749

1

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

1750

1

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

1751

1

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

1752

1

])

1753

1

        .with_para_ids(vec![

1754

1

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

1755

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1756

1

])

1757

1

        .build()

1758

1

        .execute_with(|| {

1759

1

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

1760

1

1761

1

            assert_noop!(

1762

1

                AuthorNoting::set_author(

1763

1

                    origin_of(ALICE.into()),

1764

1

                    other_para,

1765

1

1,

1766

1

                    AccountId::from(DAVE),

1767

1

                    1.into()

1768

1

),

1769

1

                BadOrigin

1770

1

);

1771

1772

1

            assert_noop!(

1773

1

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

1774

1

                BadOrigin

1775

1

);

1776

1

});

1777

1

1778

1779

#[test]

1780

1

fn test_author_noting_runtime_api() {

1781

1

    ExtBuilder::default()

1782

1

        .with_balances(vec![

1783

1

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

1784

1

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

1785

1

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

1786

1

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

1787

1

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

1788

1

])

1789

1

        .with_collators(vec![

1790

1

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

1791

1

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

1792

1

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

1793

1

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

1794

1

])

1795

1

        .with_para_ids(vec![

1796

1

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

1797

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1798

1

])

1799

1

        .build()

1800

1

        .execute_with(|| {

1801

1

            let mut sproof = ParaHeaderSproofBuilder::default();

1802

1

            let slot: u64 = 5;

1803

1

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

1804

1

1805

1

            // Charlie and Dave to 1001

1806

1

            let assignment = CollatorAssignment::collator_container_chain();

1807

1

            assert_eq!(

1808

1

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

1809

1

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

1810

1

);

1811

1812

1

            let s = ParaHeaderSproofBuilderItem {

1813

1

                para_id: other_para,

1814

1

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

1815

1

                    parent_hash: Default::default(),

1816

1

                    number: 1,

1817

1

                    state_root: Default::default(),

1818

1

                    extrinsics_root: Default::default(),

1819

1

                    digest: sp_runtime::generic::Digest {

1820

1

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

1821

1

},

1822

1

}),

1823

1

};

1824

1

            sproof.items.push(s);

1825

1

1826

1

            set_author_noting_inherent_data(sproof);

1827

1

1828

1

            assert_eq!(

1829

1

                AuthorNoting::latest_author(other_para),

1830

1

                Some(ContainerChainBlockInfo {

1831

1

                    block_number: 1,

1832

1

                    author: AccountId::from(DAVE),

1833

1

                    latest_slot_number: 0.into(),

1834

1

})

1835

1

);

1836

1837

1

            assert_eq!(

1838

1

                Runtime::latest_author(other_para),

1839

1

                Some(AccountId::from(DAVE))

1840

1

);

1841

1

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

1842

1

});

1843

1

1844

1845

#[test]

1846

1

fn test_collator_assignment_rotation() {

1847

1

    ExtBuilder::default()

1848

1

        .with_balances(vec![

1849

1

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

1850

1

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

1851

1

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

1852

1

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

1853

1

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

1854

1

])

1855

1

        .with_collators(vec![

1856

1

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

1857

1

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

1858

1

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

1859

1

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

1860

1

])

1861

1

        .with_para_ids(vec![

1862

1

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

1863

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1864

1

])

1865

1

        .build()

1866

1

        .execute_with(|| {

1867

1

            // Charlie and Dave to 1001

1868

1

            let assignment = CollatorAssignment::collator_container_chain();

1869

1

            let initial_assignment = assignment.clone();

1870

1

            assert_eq!(

1871

1

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

1872

1

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

1873

1

);

1874

1875

1

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

1876

1

            run_to_session(rotation_period - 2);

1877

1

            set_parachain_inherent_data_random_seed([1; 32]);

1878

1

            run_block();

1879

1

1880

1

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

1881

1882

1

            run_to_session(rotation_period - 1);

1883

1

            assert_eq!(

1884

1

                CollatorAssignment::collator_container_chain(),

1885

1

                initial_assignment,

1886

1

);

1887

1

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

1888

1889

1

            run_to_session(rotation_period);

1890

1

            // Assignment changed

1891

1

            assert_ne!(

1892

1

                CollatorAssignment::collator_container_chain(),

1893

1

                initial_assignment,

1894

1

);

1895

1

});

1896

1

1897

1898

#[test]

1899

1

fn session_keys_key_type_id() {

1900

1

    assert_eq!(

1901

1

        dancebox_runtime::SessionKeys::key_ids(),

1902

1

        vec![NIMBUS_KEY_ID]

1903

1

);

1904

1

1905

1906

#[test]

1907

1

fn test_session_keys_with_authority_mapping() {

1908

1

    ExtBuilder::default()

1909

1

        .with_balances(vec![

1910

1

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

1911

1

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

1912

1

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

1913

1

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

1914

1

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

1915

1

])

1916

1

        .with_para_ids(vec![

1917

1

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

1918

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1919

1

])

1920

1

        .build()

1921

1

        .execute_with(|| {

1922

1

            run_to_block(2);

1923

1

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

1924

1

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

1925

1

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

1926

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

1927

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

1928

1

1929

1

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

1930

1

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

1931

1

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

1932

1933

            // Everything should match to aura

1934

1

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

1935

1936

            // Change Alice and Bob keys to something different

1937

            // for now lets change it to alice_2 and bob_2

1938

1

            assert_ok!(Session::set_keys(

1939

1

                origin_of(ALICE.into()),

1940

1

                dancebox_runtime::SessionKeys {

1941

1

                    nimbus: alice_id_2.clone(),

1942

1

},

1943

1

                vec![]

1944

1

));

1945

1

            assert_ok!(Session::set_keys(

1946

1

                origin_of(BOB.into()),

1947

1

                dancebox_runtime::SessionKeys {

1948

1

                    nimbus: bob_id_2.clone(),

1949

1

},

1950

1

                vec![]

1951

1

));

1952

1953

1

            run_to_session(1u32);

1954

1

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

1955

1

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

1956

1

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

1957

1

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

1958

1959

1

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

1960

1

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

1961

1

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

1962

1

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

1963

1964

            // Everything should match to aura

1965

1

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

1966

//

1967

1968

1

            run_to_session(2u32);

1969

1

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

1970

1971

1

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

1972

1

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

1973

1

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

1974

1

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

1975

1976

1

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

1977

1

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

1978

1

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

1979

1

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

1980

1981

            // Everything should match to aura

1982

1

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

1983

1

});

1984

1

1985

1986

#[test]

1987

1

fn test_session_keys_with_authority_assignment() {

1988

1

    ExtBuilder::default()

1989

1

        .with_balances(vec![

1990

1

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

1991

1

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

1992

1

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

1993

1

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

1994

1

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

1995

1

])

1996

1

        .with_para_ids(vec![

1997

1

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

1998

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

1999

1

])

2000

1

        .build()

2001

1

        .execute_with(|| {

2002

1

            run_to_block(2);

2003

1

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

2004

1

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

2005

1

            let alice_id_2 = get_aura_id_from_seed("ALICE2");

2006

1

            let bob_id_2 = get_aura_id_from_seed("BOB2");

2007

1

2008

1

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

2009

1

            assert_eq!(

2010

1

                key_mapping_session_0.orchestrator_chain,

2011

1

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

2012

1

);

2013

1

            assert_eq!(

2014

1

                CollatorAssignment::collator_container_chain().orchestrator_chain,

2015

1

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

2016

1

);

2017

2018

1

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

2019

1

            assert_eq!(key_mapping_session_1, key_mapping_session_0,);

2020

1

            let old_assignment_session_1 =

2021

1

                CollatorAssignment::pending_collator_container_chain().unwrap();

2022

1

            assert_eq!(

2023

1

                old_assignment_session_1,

2024

1

                CollatorAssignment::collator_container_chain(),

2025

1

);

2026

2027

1

            let key_mapping_session_2 = AuthorityAssignment::collator_container_chain(2);

2028

1

            assert!(key_mapping_session_2.is_none());

2029

2030

            // Everything should match to aura

2031

1

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

2032

2033

            // Change Alice and Bob keys to something different

2034

            // for now lets change it to alice_2 and bob_2

2035

1

            assert_ok!(Session::set_keys(

2036

1

                origin_of(ALICE.into()),

2037

1

                dancebox_runtime::SessionKeys {

2038

1

                    nimbus: alice_id_2.clone(),

2039

1

},

2040

1

                vec![]

2041

1

));

2042

1

            assert_ok!(Session::set_keys(

2043

1

                origin_of(BOB.into()),

2044

1

                dancebox_runtime::SessionKeys {

2045

1

                    nimbus: bob_id_2.clone(),

2046

1

},

2047

1

                vec![]

2048

1

));

2049

2050

1

            run_to_session(1u32);

2051

1

            let old_key_mapping_session_1 = key_mapping_session_1;

2052

1

2053

1

            // Session 0 got removed

2054

1

            let key_mapping_session_0 = AuthorityAssignment::collator_container_chain(0);

2055

1

            assert!(key_mapping_session_0.is_none());

2056

2057

            // The values at session 1 did not change

2058

1

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

2059

1

            assert_eq!(key_mapping_session_1, old_key_mapping_session_1,);

2060

1

            assert_eq!(

2061

1

                CollatorAssignment::collator_container_chain(),

2062

1

                old_assignment_session_1,

2063

1

);

2064

2065

            // Session 2 uses the new keys

2066

1

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

2067

1

            assert_eq!(

2068

1

                key_mapping_session_2.orchestrator_chain,

2069

1

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

2070

1

);

2071

1

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

2072

2073

1

            let key_mapping_session_3 = AuthorityAssignment::collator_container_chain(3);

2074

1

            assert!(key_mapping_session_3.is_none());

2075

2076

            // Everything should match to aura

2077

1

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

2078

2079

1

            run_to_session(2u32);

2080

1

2081

1

            // Session 1 got removed

2082

1

            let key_mapping_session_1 = AuthorityAssignment::collator_container_chain(1);

2083

1

            assert!(key_mapping_session_1.is_none());

2084

2085

            // Session 2 uses the new keys

2086

1

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

2087

1

            assert_eq!(

2088

1

                key_mapping_session_2.orchestrator_chain,

2089

1

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

2090

1

);

2091

1

            assert_eq!(

2092

1

                old_assignment_session_1,

2093

1

                CollatorAssignment::collator_container_chain(),

2094

1

);

2095

2096

            // Session 3 uses the new keys

2097

1

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

2098

1

            assert_eq!(

2099

1

                key_mapping_session_3.orchestrator_chain,

2100

1

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

2101

1

);

2102

1

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

2103

2104

1

            let key_mapping_session_4 = AuthorityAssignment::collator_container_chain(4);

2105

1

            assert!(key_mapping_session_4.is_none());

2106

2107

            // Everything should match to aura

2108

1

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

2109

1

});

2110

1

2111

2112

2

fn call_transfer(

2113

2

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

2114

2

    value: u128,

2115

2

) -> RuntimeCall {

2116

2

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

2117

2

2118

2119

#[test]

2120

1

fn test_proxy_any() {

2121

1

    ExtBuilder::default()

2122

1

        .with_balances(vec![

2123

1

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

2124

1

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

2125

1

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

2126

1

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

2127

1

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

2128

1

])

2129

1

        .build()

2130

1

        .execute_with(|| {

2131

1

            run_to_block(2);

2132

1

2133

1

            let delay = 0;

2134

1

            assert_ok!(Proxy::add_proxy(

2135

1

                origin_of(ALICE.into()),

2136

1

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

2137

1

                ProxyType::Any,

2138

1

                delay

2139

1

));

2140

2141

1

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

2142

1

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

2143

1

            assert_ok!(Proxy::proxy(

2144

1

                origin_of(BOB.into()),

2145

1

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

2146

1

                None,

2147

1

                call

2148

1

));

2149

1

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

2150

1

2151

1

            assert_eq!(balance_after, balance_before + 200_000);

2152

1

});

2153

1

2154

2155

#[test]

2156

1

fn test_proxy_non_transfer() {

2157

1

    ExtBuilder::default()

2158

1

        .with_balances(vec![

2159

1

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

2160

1

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

2161

1

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

2162

1

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

2163

1

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

2164

1

])

2165

1

        .build()

2166

1

        .execute_with(|| {

2167

1

            run_to_block(2);

2168

1

2169

1

            let delay = 0;

2170

1

            assert_ok!(Proxy::add_proxy(

2171

1

                origin_of(ALICE.into()),

2172

1

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

2173

1

                ProxyType::NonTransfer,

2174

1

                delay

2175

1

));

2176

2177

1

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

2178

1

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

2179

1

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

2180

1

            assert_ok!(Proxy::proxy(

2181

1

                origin_of(BOB.into()),

2182

1

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

2183

1

                None,

2184

1

                call

2185

1

));

2186

1

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

2187

1

2188

1

            assert_eq!(balance_after, balance_before);

2189

1

});

2190

1

2191

2192

#[test]

2193

1

fn test_proxy_utility() {

2194

1

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

2195

1

    // subcalls don't allow to circumvent filters.

2196

1

2197

1

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

2198

1

    match ProxyType::Any {

2199

        ProxyType::Any

2200

        | ProxyType::NonTransfer

2201

        | ProxyType::Governance

2202

        | ProxyType::Staking

2203

        | ProxyType::CancelProxy

2204

        | ProxyType::Balances

2205

        | ProxyType::Registrar

2206

        | ProxyType::SudoRegistrar

2207

1

        | ProxyType::SessionKeyManagement => (),

2208

1

};

2209

1

2210

1

    // All except for any

2211

1

    let proxy_types = &[

2212

1

        ProxyType::NonTransfer,

2213

1

        ProxyType::Governance,

2214

1

        ProxyType::Staking,

2215

1

        ProxyType::CancelProxy,

2216

1

        ProxyType::Balances,

2217

1

        ProxyType::Registrar,

2218

1

        ProxyType::SudoRegistrar,

2219

1

        ProxyType::SessionKeyManagement,

2220

1

];

2221

2222

9

    for &proxy_type in proxy_types {

2223

8

        ExtBuilder::default()

2224

8

            .with_balances(vec![

2225

8

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

2226

8

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

2227

8

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

2228

8

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

2229

8

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

2230

8

])

2231

8

            .with_collators(vec![

2232

8

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

2233

8

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

2234

8

])

2235

8

            .with_sudo(AccountId::from(ALICE))

2236

8

            .build()

2237

8

            .execute_with(|| {

2238

8

                assert_ok!(Proxy::add_proxy(

2239

8

                    origin_of(ALICE.into()),

2240

8

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

2241

8

                    proxy_type,

2242

8

2243

8

));

2244

2245

8

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

2246

8

2247

8

                assert_ok!(Proxy::proxy(

2248

8

                    origin_of(BOB.into()),

2249

8

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

2250

8

                    None,

2251

8

                    Box::new(

2252

8

                        pallet_sudo::Call::sudo {

2253

8

                            call: Box::new(

2254

8

                                pallet_utility::Call::batch {

2255

8

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

2256

8

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

2257

8

                                        new_free: 42424242424242

2258

8

2259

8

                                    .into()]

2260

8

2261

8

                                .into()

2262

8

2263

8

2264

8

                        .into()

2265

8

2266

8

));

2267

2268

8

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

2269

8

});

2270

8

2271

1

2272

2273

#[test]

2274

1

fn check_well_known_keys() {

2275

1

    use frame_support::traits::PalletInfo;

2276

1

2277

1

    // Pallet is named "Paras" in Polkadot.

2278

1

    assert_eq!(

2279

1

        well_known_keys::PARAS_HEADS_INDEX,

2280

1

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

2281

1

);

2282

2283

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

2284

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

2285

1

    assert_eq!(

2286

1

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

2287

1

        Some("AuthorityAssignment")

2288

1

);

2289

1

    assert_eq!(

2290

1

        well_known_keys::AUTHORITY_ASSIGNMENT_PREFIX,

2291

1

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

2292

1

);

2293

2294

1

    assert_eq!(

2295

1

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

2296

1

        Some("Session")

2297

1

);

2298

1

    assert_eq!(

2299

1

        well_known_keys::SESSION_INDEX,

2300

1

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

2301

1

);

2302

1

2303

2304

#[test]

2305

1

fn test_staking_no_candidates_in_genesis() {

2306

1

    ExtBuilder::default()

2307

1

        .with_balances(vec![

2308

1

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

2309

1

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

2310

1

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

2311

1

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

2312

1

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

2313

1

])

2314

1

        .with_collators(vec![

2315

1

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

2316

1

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

2317

1

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

2318

1

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

2319

1

])

2320

1

        .with_para_ids(vec![

2321

1

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

2322

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2323

1

])

2324

1

        .build()

2325

1

        .execute_with(|| {

2326

1

            run_to_block(2);

2327

1

2328

1

            let initial_candidates =

2329

1

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

2330

1

2331

1

            assert_eq!(initial_candidates, vec![]);

2332

1

});

2333

1

2334

2335

#[test]

2336

1

fn test_staking_join() {

2337

1

    ExtBuilder::default()

2338

1

        .with_balances(vec![

2339

1

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

2340

1

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

2341

1

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

2342

1

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

2343

1

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

2344

1

])

2345

1

        .with_collators(vec![

2346

1

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

2347

1

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

2348

1

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

2349

1

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

2350

1

])

2351

1

        .with_para_ids(vec![

2352

1

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

2353

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2354

1

])

2355

1

        .build()

2356

1

        .execute_with(|| {

2357

1

            run_to_block(2);

2358

1

2359

1

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

2360

1

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

2361

1

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

2362

1

            assert_ok!(PooledStaking::request_delegate(

2363

1

                origin_of(ALICE.into()),

2364

1

                ALICE.into(),

2365

1

                TargetPool::AutoCompounding,

2366

1

                stake

2367

1

));

2368

2369

            // Immediately after joining, Alice is the top candidate

2370

1

            let eligible_candidates =

2371

1

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

2372

1

            assert_eq!(

2373

1

                eligible_candidates,

2374

1

                vec![EligibleCandidate {

2375

1

                    candidate: ALICE.into(),

2376

1

                    stake

2377

1

}]

2378

1

);

2379

2380

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

2381

1

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

2382

1

            assert_eq!(balance_before - balance_after, stake);

2383

1

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

2384

1

});

2385

1

2386

2387

#[test]

2388

1

fn test_staking_join_no_keys_registered() {

2389

1

    ExtBuilder::default()

2390

1

        .with_balances(vec![

2391

1

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

2392

1

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

2393

1

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

2394

1

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

2395

1

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

2396

1

])

2397

1

        .with_collators(vec![

2398

1

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

2399

1

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

2400

1

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

2401

1

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

2402

1

])

2403

1

        .with_para_ids(vec![

2404

1

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

2405

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2406

1

])

2407

1

2408

1

        .build()

2409

1

        .execute_with(|| {

2410

1

            run_to_block(2);

2411

1

2412

1

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

2413

1

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

2414

1

            assert_ok!(Balances::transfer_allow_death(

2415

1

                origin_of(ALICE.into()),

2416

1

                new_account.clone().into(),

2417

1

                stake * 2

2418

1

));

2419

1

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

2420

1

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

2421

1

            assert_ok!(PooledStaking::request_delegate(

2422

1

                origin_of(new_account.clone()),

2423

1

                new_account.clone(),

2424

1

                TargetPool::AutoCompounding,

2425

1

                stake

2426

1

));

2427

2428

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

2429

            // pallet_session, so it is not eligible

2430

1

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

2431

1

            let eligible_candidates =

2432

1

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

2433

1

2434

1

            assert_eq!(eligible_candidates, vec![]);

2435

2436

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

2437

1

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

2438

1

            assert_eq!(balance_before - balance_after, stake);

2439

1

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

2440

1

});

2441

1

2442

2443

#[test]

2444

1

fn test_staking_register_keys_after_joining() {

2445

1

    ExtBuilder::default()

2446

1

        .with_balances(vec![

2447

1

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

2448

1

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

2449

1

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

2450

1

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

2451

1

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

2452

1

])

2453

1

        .with_collators(vec![

2454

1

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

2455

1

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

2456

1

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

2457

1

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

2458

1

])

2459

1

        .with_para_ids(vec![

2460

1

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

2461

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2462

1

])

2463

1

2464

1

        .build()

2465

1

        .execute_with(|| {

2466

1

            run_to_block(2);

2467

1

2468

1

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

2469

1

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

2470

1

            assert_ok!(Balances::transfer_allow_death(

2471

1

                origin_of(ALICE.into()),

2472

1

                new_account.clone().into(),

2473

1

                stake * 2

2474

1

));

2475

1

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

2476

1

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

2477

1

            assert_ok!(PooledStaking::request_delegate(

2478

1

                origin_of(new_account.clone()),

2479

1

                new_account.clone(),

2480

1

                TargetPool::AutoCompounding,

2481

1

                stake

2482

1

));

2483

2484

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

2485

            // pallet_session, so it is not eligible

2486

1

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

2487

1

            let eligible_candidates =

2488

1

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

2489

1

            assert_eq!(eligible_candidates, vec![]);

2490

2491

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

2492

1

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

2493

1

            assert_eq!(balance_before - balance_after, stake);

2494

1

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

2495

2496

            // Now register the keys

2497

1

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

2498

1

            assert_ok!(Session::set_keys(

2499

1

                origin_of(new_account.clone()),

2500

1

                dancebox_runtime::SessionKeys {

2501

1

                    nimbus: new_account_id,

2502

1

},

2503

1

                vec![]

2504

1

));

2505

2506

            // Now eligible according to filter

2507

1

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

2508

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

2509

1

            let eligible_candidates =

2510

1

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

2511

1

            assert_eq!(eligible_candidates, vec![]);

2512

2513

            // Update candidate list

2514

1

            assert_ok!(PooledStaking::update_candidate_position(

2515

1

                origin_of(BOB.into()),

2516

1

                vec![new_account.clone()]

2517

1

));

2518

2519

            // Now it is eligible

2520

1

            let eligible_candidates =

2521

1

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

2522

1

            assert_eq!(

2523

1

                eligible_candidates,

2524

1

                vec![EligibleCandidate {

2525

1

                    candidate: new_account.clone(),

2526

1

                    stake

2527

1

}]

2528

1

);

2529

1

});

2530

1

2531

2532

#[test]

2533

1

fn test_staking_join_bad_origin() {

2534

1

    ExtBuilder::default()

2535

1

        .with_balances(vec![

2536

1

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

2537

1

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

2538

1

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

2539

1

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

2540

1

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

2541

1

])

2542

1

        .with_collators(vec![

2543

1

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

2544

1

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

2545

1

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

2546

1

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

2547

1

])

2548

1

        .with_para_ids(vec![

2549

1

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

2550

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2551

1

])

2552

1

        .build()

2553

1

        .execute_with(|| {

2554

1

            run_to_block(2);

2555

1

2556

1

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

2557

1

            assert_noop!(

2558

1

                PooledStaking::request_delegate(

2559

1

                    root_origin(),

2560

1

                    ALICE.into(),

2561

1

                    TargetPool::AutoCompounding,

2562

1

                    stake

2563

1

),

2564

1

                BadOrigin,

2565

1

);

2566

1

});

2567

1

2568

2569

#[test]

2570

1

fn test_staking_join_below_self_delegation_min() {

2571

1

    ExtBuilder::default()

2572

1

        .with_balances(vec![

2573

1

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

2574

1

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

2575

1

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

2576

1

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

2577

1

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

2578

1

])

2579

1

        .with_collators(vec![

2580

1

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

2581

1

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

2582

1

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

2583

1

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

2584

1

])

2585

1

        .with_para_ids(vec![

2586

1

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

2587

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2588

1

])

2589

1

        .build()

2590

1

        .execute_with(|| {

2591

1

            run_to_block(2);

2592

1

2593

1

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

2594

1

            assert_ok!(PooledStaking::request_delegate(

2595

1

                origin_of(ALICE.into()),

2596

1

                ALICE.into(),

2597

1

                TargetPool::AutoCompounding,

2598

1

                stake1

2599

1

));

2600

2601

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

2602

            // but the candidate is not eligible

2603

1

            let eligible_candidates =

2604

1

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

2605

1

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

2606

2607

1

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

2608

1

            assert_ok!(PooledStaking::request_delegate(

2609

1

                origin_of(ALICE.into()),

2610

1

                ALICE.into(),

2611

1

                TargetPool::AutoCompounding,

2612

1

                stake2,

2613

1

));

2614

2615

            // Still below, missing 1 unit

2616

1

            let eligible_candidates =

2617

1

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

2618

1

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

2619

2620

1

            let stake3 = 1;

2621

1

            assert_ok!(PooledStaking::request_delegate(

2622

1

                origin_of(ALICE.into()),

2623

1

                ALICE.into(),

2624

1

                TargetPool::AutoCompounding,

2625

1

                stake3,

2626

1

));

2627

2628

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

2629

1

            let eligible_candidates =

2630

1

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

2631

1

            assert_eq!(

2632

1

                eligible_candidates,

2633

1

                vec![EligibleCandidate {

2634

1

                    candidate: ALICE.into(),

2635

1

                    stake: stake1 + stake2 + stake3

2636

1

}],

2637

1

);

2638

1

});

2639

1

2640

2641

#[test]

2642

1

fn test_staking_join_no_self_delegation() {

2643

1

    ExtBuilder::default()

2644

1

        .with_balances(vec![

2645

1

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

2646

1

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

2647

1

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

2648

1

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

2649

1

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

2650

1

])

2651

1

        .with_collators(vec![

2652

1

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

2653

1

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

2654

1

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

2655

1

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

2656

1

])

2657

1

        .with_para_ids(vec![

2658

1

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

2659

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2660

1

])

2661

1

        .build()

2662

1

        .execute_with(|| {

2663

1

            run_to_block(2);

2664

1

2665

1

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

2666

1

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

2667

1

            assert_ok!(PooledStaking::request_delegate(

2668

1

                origin_of(BOB.into()),

2669

1

                ALICE.into(),

2670

1

                TargetPool::AutoCompounding,

2671

1

                stake,

2672

1

));

2673

2674

1

            let eligible_candidates =

2675

1

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

2676

1

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

2677

1

});

2678

1

2679

2680

#[test]

2681

1

fn test_staking_join_before_self_delegation() {

2682

1

    ExtBuilder::default()

2683

1

        .with_balances(vec![

2684

1

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

2685

1

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

2686

1

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

2687

1

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

2688

1

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

2689

1

])

2690

1

        .with_collators(vec![

2691

1

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

2692

1

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

2693

1

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

2694

1

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

2695

1

])

2696

1

        .with_para_ids(vec![

2697

1

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

2698

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2699

1

])

2700

1

        .build()

2701

1

        .execute_with(|| {

2702

1

            run_to_block(2);

2703

1

2704

1

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

2705

1

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

2706

1

            assert_ok!(PooledStaking::request_delegate(

2707

1

                origin_of(BOB.into()),

2708

1

                ALICE.into(),

2709

1

                TargetPool::AutoCompounding,

2710

1

                stake

2711

1

));

2712

2713

1

            let eligible_candidates =

2714

1

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

2715

1

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

2716

2717

1

            run_to_session(2);

2718

1

            assert_ok!(PooledStaking::execute_pending_operations(

2719

1

                origin_of(ALICE.into()),

2720

1

                vec![PendingOperationQuery {

2721

1

                    delegator: BOB.into(),

2722

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2723

1

                        candidate: ALICE.into(),

2724

1

                        at: 0,

2725

1

2726

1

}]

2727

1

            ),);

2728

2729

            // Now Alice joins with enough self-delegation

2730

1

            assert_ok!(PooledStaking::request_delegate(

2731

1

                origin_of(ALICE.into()),

2732

1

                ALICE.into(),

2733

1

                TargetPool::AutoCompounding,

2734

1

                stake

2735

1

));

2736

2737

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

2738

1

            let eligible_candidates =

2739

1

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

2740

1

            assert_eq!(

2741

1

                eligible_candidates,

2742

1

                vec![EligibleCandidate {

2743

1

                    candidate: ALICE.into(),

2744

1

                    stake: stake * 2,

2745

1

}],

2746

1

);

2747

1

});

2748

1

2749

2750

#[test]

2751

1

fn test_staking_join_twice_in_same_block() {

2752

1

    ExtBuilder::default()

2753

1

        .with_balances(vec![

2754

1

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

2755

1

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

2756

1

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

2757

1

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

2758

1

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

2759

1

])

2760

1

        .with_collators(vec![

2761

1

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

2762

1

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

2763

1

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

2764

1

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

2765

1

])

2766

1

        .with_para_ids(vec![

2767

1

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

2768

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2769

1

])

2770

1

        .build()

2771

1

        .execute_with(|| {

2772

1

            run_to_block(2);

2773

1

2774

1

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

2775

1

            assert_ok!(PooledStaking::request_delegate(

2776

1

                origin_of(ALICE.into()),

2777

1

                ALICE.into(),

2778

1

                TargetPool::AutoCompounding,

2779

1

                stake1

2780

1

));

2781

2782

1

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

2783

1

            assert_ok!(PooledStaking::request_delegate(

2784

1

                origin_of(ALICE.into()),

2785

1

                ALICE.into(),

2786

1

                TargetPool::AutoCompounding,

2787

1

                stake2

2788

1

));

2789

2790

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

2791

1

            let eligible_candidates =

2792

1

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

2793

1

2794

1

            assert_eq!(

2795

1

                eligible_candidates,

2796

1

                vec![EligibleCandidate {

2797

1

                    candidate: ALICE.into(),

2798

1

                    stake: stake1 + stake2,

2799

1

}]

2800

1

);

2801

2802

1

            run_to_session(2);

2803

1

2804

1

            assert_ok!(PooledStaking::execute_pending_operations(

2805

1

                origin_of(ALICE.into()),

2806

1

                vec![PendingOperationQuery {

2807

1

                    delegator: ALICE.into(),

2808

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2809

1

                        candidate: ALICE.into(),

2810

1

                        at: 0,

2811

1

2812

1

}]

2813

1

            ),);

2814

2815

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

2816

1

});

2817

1

2818

2819

#[test]

2820

1

fn test_staking_join_execute_before_time() {

2821

1

    ExtBuilder::default()

2822

1

        .with_balances(vec![

2823

1

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

2824

1

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

2825

1

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

2826

1

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

2827

1

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

2828

1

])

2829

1

        .with_collators(vec![

2830

1

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

2831

1

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

2832

1

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

2833

1

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

2834

1

])

2835

1

        .with_para_ids(vec![

2836

1

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

2837

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2838

1

])

2839

1

        .build()

2840

1

        .execute_with(|| {

2841

1

            run_to_block(2);

2842

1

2843

1

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

2844

1

            assert_ok!(PooledStaking::request_delegate(

2845

1

                origin_of(ALICE.into()),

2846

1

                ALICE.into(),

2847

1

                TargetPool::AutoCompounding,

2848

1

                stake

2849

1

));

2850

2851

            // Immediately after joining, Alice is the top candidate

2852

1

            let eligible_candidates =

2853

1

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

2854

1

            assert_eq!(

2855

1

                eligible_candidates,

2856

1

                vec![EligibleCandidate {

2857

1

                    candidate: ALICE.into(),

2858

1

                    stake

2859

1

}]

2860

1

);

2861

2862

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

2863

1

            let start_of_session_2 = session_to_block(2);

2864

1

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

2865

1

            run_to_block(start_of_session_2 - 2);

2866

1

            assert_noop!(

2867

1

                PooledStaking::execute_pending_operations(

2868

1

                    origin_of(ALICE.into()),

2869

1

                    vec![PendingOperationQuery {

2870

1

                        delegator: ALICE.into(),

2871

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

2872

1

                            candidate: ALICE.into(),

2873

1

                            at: 0,

2874

1

2875

1

}]

2876

1

),

2877

1

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

2878

1

);

2879

2880

1

            run_to_block(start_of_session_2);

2881

1

            assert_ok!(PooledStaking::execute_pending_operations(

2882

1

                origin_of(ALICE.into()),

2883

1

                vec![PendingOperationQuery {

2884

1

                    delegator: ALICE.into(),

2885

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2886

1

                        candidate: ALICE.into(),

2887

1

                        at: 0,

2888

1

2889

1

}]

2890

1

            ),);

2891

1

});

2892

1

2893

2894

#[test]

2895

1

fn test_staking_join_execute_any_origin() {

2896

1

    ExtBuilder::default()

2897

1

        .with_balances(vec![

2898

1

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

2899

1

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

2900

1

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

2901

1

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

2902

1

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

2903

1

])

2904

1

        .with_collators(vec![

2905

1

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

2906

1

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

2907

1

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

2908

1

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

2909

1

])

2910

1

        .with_para_ids(vec![

2911

1

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

2912

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2913

1

])

2914

1

        .build()

2915

1

        .execute_with(|| {

2916

1

            run_to_block(2);

2917

1

2918

1

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

2919

1

            assert_ok!(PooledStaking::request_delegate(

2920

1

                origin_of(ALICE.into()),

2921

1

                ALICE.into(),

2922

1

                TargetPool::AutoCompounding,

2923

1

                stake

2924

1

));

2925

2926

            // Immediately after joining, Alice is the top candidate

2927

1

            let eligible_candidates =

2928

1

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

2929

1

            assert_eq!(

2930

1

                eligible_candidates,

2931

1

                vec![EligibleCandidate {

2932

1

                    candidate: ALICE.into(),

2933

1

                    stake

2934

1

}]

2935

1

);

2936

2937

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

2938

1

            run_to_session(2);

2939

1

            // Anyone can execute pending operations for anyone else

2940

1

            assert_ok!(PooledStaking::execute_pending_operations(

2941

1

                origin_of(BOB.into()),

2942

1

                vec![PendingOperationQuery {

2943

1

                    delegator: ALICE.into(),

2944

1

                    operation: PendingOperationKey::JoiningAutoCompounding {

2945

1

                        candidate: ALICE.into(),

2946

1

                        at: 0,

2947

1

2948

1

}]

2949

1

            ),);

2950

1

});

2951

1

2952

2953

#[test]

2954

1

fn test_staking_join_execute_bad_origin() {

2955

1

    ExtBuilder::default()

2956

1

        .with_balances(vec![

2957

1

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

2958

1

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

2959

1

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

2960

1

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

2961

1

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

2962

1

])

2963

1

        .with_collators(vec![

2964

1

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

2965

1

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

2966

1

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

2967

1

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

2968

1

])

2969

1

        .with_para_ids(vec![

2970

1

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

2971

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

2972

1

])

2973

1

        .build()

2974

1

        .execute_with(|| {

2975

1

            run_to_block(2);

2976

1

2977

1

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

2978

1

            assert_ok!(PooledStaking::request_delegate(

2979

1

                origin_of(ALICE.into()),

2980

1

                ALICE.into(),

2981

1

                TargetPool::AutoCompounding,

2982

1

                stake

2983

1

));

2984

2985

            // Immediately after joining, Alice is the top candidate

2986

1

            let eligible_candidates =

2987

1

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

2988

1

            assert_eq!(

2989

1

                eligible_candidates,

2990

1

                vec![EligibleCandidate {

2991

1

                    candidate: ALICE.into(),

2992

1

                    stake

2993

1

}]

2994

1

);

2995

2996

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

2997

1

            run_to_session(2);

2998

1

            assert_noop!(

2999

1

                PooledStaking::execute_pending_operations(

3000

1

                    root_origin(),

3001

1

                    vec![PendingOperationQuery {

3002

1

                        delegator: ALICE.into(),

3003

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3004

1

                            candidate: ALICE.into(),

3005

1

                            at: 0,

3006

1

3007

1

}]

3008

1

),

3009

1

                BadOrigin,

3010

1

);

3011

1

});

3012

1

3013

3014

struct A {

3015

    delegator: AccountId,

3016

    candidate: AccountId,

3017

    target_pool: TargetPool,

3018

    stake: u128,

3019

3020

3021

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

3022

9

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

3023

9

    ExtBuilder::default()

3024

9

        .with_balances(vec![

3025

9

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

3026

9

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

3027

9

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

3028

9

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

3029

9

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

3030

9

])

3031

9

        .with_collators(vec![

3032

9

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

3033

9

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

3034

9

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

3035

9

            (AccountId::from(DAVE), 100 * UNIT),

3036

9

])

3037

9

        .with_para_ids(vec![

3038

9

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3039

9

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3040

9

])

3041

9

        .build()

3042

9

        .execute_with(|| {

3043

9

            run_to_block(2);

3044

3045

9

            for op in ops.iter() {

3046

9

                assert_ok!(PooledStaking::request_delegate(

3047

9

                    origin_of(op.delegator.clone()),

3048

9

                    op.candidate.clone(),

3049

9

                    op.target_pool,

3050

9

                    op.stake,

3051

9

));

3052

3053

3054

            // We called request_delegate in session 0, we will be able to execute it starting from session 2

3055

9

            run_to_session(2);

3056

3057

9

            for op in ops.iter() {

3058

9

                let operation = match op.target_pool {

3059

9

                    TargetPool::AutoCompounding => PendingOperationKey::JoiningAutoCompounding {

3060

9

                        candidate: op.candidate.clone(),

3061

9

                        at: 0,

3062

9

},

3063

                    TargetPool::ManualRewards => PendingOperationKey::JoiningManualRewards {

3064

                        candidate: op.candidate.clone(),

3065

                        at: 0,

3066

},

3067

};

3068

3069

9

                assert_ok!(PooledStaking::execute_pending_operations(

3070

9

                    origin_of(op.delegator.clone()),

3071

9

                    vec![PendingOperationQuery {

3072

9

                        delegator: op.delegator.clone(),

3073

9

                        operation,

3074

9

}]

3075

9

));

3076

3077

3078

9

f()

3079

9

});

3080

9

3081

3082

#[test]

3083

1

fn test_staking_leave_exact_amount() {

3084

1

    setup_staking_join_and_execute(

3085

1

        vec![A {

3086

1

            delegator: ALICE.into(),

3087

1

            candidate: ALICE.into(),

3088

1

            target_pool: TargetPool::AutoCompounding,

3089

1

            stake: 10 * MinimumSelfDelegation::get(),

3090

1

}],

3091

1

        || {

3092

1

            let stake = 10 * MinimumSelfDelegation::get();

3093

1

            assert_ok!(PooledStaking::request_undelegate(

3094

1

                origin_of(ALICE.into()),

3095

1

                ALICE.into(),

3096

1

                TargetPool::AutoCompounding,

3097

1

                SharesOrStake::Stake(stake),

3098

1

));

3099

3100

            // Immediately after calling request_undelegate, Alice is no longer a candidate

3101

1

            let eligible_candidates =

3102

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3103

1

            assert_eq!(eligible_candidates, vec![]);

3104

1

},

3105

1

3106

1

3107

3108

#[test]

3109

1

fn test_staking_leave_bad_origin() {

3110

1

    setup_staking_join_and_execute(

3111

1

        vec![A {

3112

1

            delegator: ALICE.into(),

3113

1

            candidate: ALICE.into(),

3114

1

            target_pool: TargetPool::AutoCompounding,

3115

1

            stake: 10 * MinimumSelfDelegation::get(),

3116

1

}],

3117

1

        || {

3118

1

            let stake = 10 * MinimumSelfDelegation::get();

3119

1

            assert_noop!(

3120

1

                PooledStaking::request_undelegate(

3121

1

                    root_origin(),

3122

1

                    ALICE.into(),

3123

1

                    TargetPool::AutoCompounding,

3124

1

                    SharesOrStake::Stake(stake),

3125

1

),

3126

1

                BadOrigin

3127

1

);

3128

1

},

3129

1

3130

1

3131

3132

#[test]

3133

1

fn test_staking_leave_more_than_allowed() {

3134

1

    setup_staking_join_and_execute(

3135

1

        vec![A {

3136

1

            delegator: ALICE.into(),

3137

1

            candidate: ALICE.into(),

3138

1

            target_pool: TargetPool::AutoCompounding,

3139

1

            stake: 10 * MinimumSelfDelegation::get(),

3140

1

}],

3141

1

        || {

3142

1

            let stake = 10 * MinimumSelfDelegation::get();

3143

1

            assert_noop!(

3144

1

                PooledStaking::request_undelegate(

3145

1

                    origin_of(ALICE.into()),

3146

1

                    ALICE.into(),

3147

1

                    TargetPool::AutoCompounding,

3148

1

                    SharesOrStake::Stake(stake + 1 * MinimumSelfDelegation::get()),

3149

1

),

3150

1

                pallet_pooled_staking::Error::<Runtime>::MathUnderflow,

3151

1

);

3152

1

},

3153

1

);

3154

1

3155

3156

#[test]

3157

1

fn test_staking_leave_in_separate_transactions() {

3158

1

    let stake = 10 * MinimumSelfDelegation::get();

3159

1

3160

1

    setup_staking_join_and_execute(

3161

1

        vec![A {

3162

1

            delegator: ALICE.into(),

3163

1

            candidate: ALICE.into(),

3164

1

            target_pool: TargetPool::AutoCompounding,

3165

1

            stake,

3166

1

}],

3167

1

        || {

3168

1

            let half_stake = stake / 2;

3169

1

            assert_ok!(PooledStaking::request_undelegate(

3170

1

                origin_of(ALICE.into()),

3171

1

                ALICE.into(),

3172

1

                TargetPool::AutoCompounding,

3173

1

                SharesOrStake::Stake(half_stake),

3174

1

));

3175

3176

            // Alice is still a valid candidate, now with less stake

3177

1

            let eligible_candidates =

3178

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3179

1

            let remaining_stake = stake - half_stake;

3180

1

            assert_eq!(

3181

1

                eligible_candidates,

3182

1

                vec![EligibleCandidate {

3183

1

                    candidate: ALICE.into(),

3184

1

                    stake: remaining_stake,

3185

1

}],

3186

1

);

3187

3188

1

            assert_ok!(PooledStaking::request_undelegate(

3189

1

                origin_of(ALICE.into()),

3190

1

                ALICE.into(),

3191

1

                TargetPool::AutoCompounding,

3192

1

                SharesOrStake::Stake(remaining_stake),

3193

1

));

3194

3195

            // Unstaked remaining stake, so no longer a valid candidate

3196

1

            let eligible_candidates =

3197

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3198

1

            assert_eq!(eligible_candidates, vec![],);

3199

1

},

3200

1

);

3201

1

3202

3203

#[test]

3204

1

fn test_staking_leave_all_except_some_dust() {

3205

1

    let stake = 10 * MinimumSelfDelegation::get();

3206

1

3207

1

    setup_staking_join_and_execute(

3208

1

        vec![A {

3209

1

            delegator: ALICE.into(),

3210

1

            candidate: ALICE.into(),

3211

1

            target_pool: TargetPool::AutoCompounding,

3212

1

            stake,

3213

1

}],

3214

1

        || {

3215

1

            let dust = MinimumSelfDelegation::get() / 2;

3216

1

            assert_ok!(PooledStaking::request_undelegate(

3217

1

                origin_of(ALICE.into()),

3218

1

                ALICE.into(),

3219

1

                TargetPool::AutoCompounding,

3220

1

                SharesOrStake::Stake(stake - dust),

3221

1

));

3222

3223

            // Alice still has some stake left, but not enough to reach MinimumSelfDelegation

3224

1

            assert_eq!(

3225

1

                pallet_pooled_staking::Pools::<Runtime>::get(

3226

1

                    AccountId::from(ALICE),

3227

1

                    PoolsKey::CandidateTotalStake

3228

1

),

3229

1

                dust,

3230

1

);

3231

3232

1

            let eligible_candidates =

3233

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3234

1

            assert_eq!(eligible_candidates, vec![],);

3235

3236

            // Leave with remaining stake

3237

1

            assert_ok!(PooledStaking::request_undelegate(

3238

1

                origin_of(ALICE.into()),

3239

1

                ALICE.into(),

3240

1

                TargetPool::AutoCompounding,

3241

1

                SharesOrStake::Stake(dust),

3242

1

));

3243

3244

            // Alice has no more stake left

3245

1

            assert_eq!(

3246

1

                pallet_pooled_staking::Pools::<Runtime>::get(

3247

1

                    AccountId::from(ALICE),

3248

1

                    PoolsKey::CandidateTotalStake

3249

1

),

3250

1

0,

3251

1

);

3252

1

},

3253

1

);

3254

1

3255

3256

#[test]

3257

1

fn test_staking_leave_execute_before_time() {

3258

1

    let stake = 10 * MinimumSelfDelegation::get();

3259

1

3260

1

    setup_staking_join_and_execute(

3261

1

        vec![A {

3262

1

            delegator: ALICE.into(),

3263

1

            candidate: ALICE.into(),

3264

1

            target_pool: TargetPool::AutoCompounding,

3265

1

            stake,

3266

1

}],

3267

1

        || {

3268

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

3269

1

            let at = Session::current_index();

3270

1

            assert_ok!(PooledStaking::request_undelegate(

3271

1

                origin_of(ALICE.into()),

3272

1

                ALICE.into(),

3273

1

                TargetPool::AutoCompounding,

3274

1

                SharesOrStake::Stake(stake),

3275

1

));

3276

3277

            // Request undelegate does not change account balance

3278

1

            assert_eq!(

3279

1

                balance_before,

3280

1

                System::account(AccountId::from(ALICE)).data.free

3281

1

);

3282

3283

            // We called request_delegate in session 0, we will be able to execute it starting from session 2

3284

1

            let start_of_session_4 = session_to_block(4);

3285

1

            // Session 4 starts at block 1200, but run_to_session runs to block 1201, so subtract 2 here to go to 1999

3286

1

            run_to_block(start_of_session_4 - 2);

3287

1

3288

1

            assert_noop!(

3289

1

                PooledStaking::execute_pending_operations(

3290

1

                    origin_of(ALICE.into()),

3291

1

                    vec![PendingOperationQuery {

3292

1

                        delegator: ALICE.into(),

3293

1

                        operation: PendingOperationKey::Leaving {

3294

1

                            candidate: ALICE.into(),

3295

1

at,

3296

1

3297

1

}]

3298

1

),

3299

1

                pallet_pooled_staking::Error::<Runtime>::RequestCannotBeExecuted(0)

3300

1

);

3301

1

},

3302

1

);

3303

1

3304

3305

#[test]

3306

1

fn test_staking_leave_execute_any_origin() {

3307

1

    let stake = 10 * MinimumSelfDelegation::get();

3308

1

3309

1

    setup_staking_join_and_execute(

3310

1

        vec![A {

3311

1

            delegator: ALICE.into(),

3312

1

            candidate: ALICE.into(),

3313

1

            target_pool: TargetPool::AutoCompounding,

3314

1

            stake,

3315

1

}],

3316

1

        || {

3317

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

3318

1

            let at = Session::current_index();

3319

1

            assert_ok!(PooledStaking::request_undelegate(

3320

1

                origin_of(ALICE.into()),

3321

1

                ALICE.into(),

3322

1

                TargetPool::AutoCompounding,

3323

1

                SharesOrStake::Stake(stake),

3324

1

));

3325

3326

            // Request undelegate does not change account balance

3327

1

            assert_eq!(

3328

1

                balance_before,

3329

1

                System::account(AccountId::from(ALICE)).data.free

3330

1

);

3331

3332

1

            run_to_session(4);

3333

1

3334

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

3335

1

3336

1

            assert_ok!(PooledStaking::execute_pending_operations(

3337

1

                // Any signed origin can execute this, the stake will go to Alice account

3338

1

                origin_of(BOB.into()),

3339

1

                vec![PendingOperationQuery {

3340

1

                    delegator: ALICE.into(),

3341

1

                    operation: PendingOperationKey::Leaving {

3342

1

                        candidate: ALICE.into(),

3343

1

at,

3344

1

3345

1

}]

3346

1

            ),);

3347

3348

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

3349

1

            assert_eq!(balance_after - balance_before, stake);

3350

1

},

3351

1

);

3352

1

3353

3354

#[test]

3355

1

fn test_staking_leave_execute_bad_origin() {

3356

1

    let stake = 10 * MinimumSelfDelegation::get();

3357

1

3358

1

    setup_staking_join_and_execute(

3359

1

        vec![A {

3360

1

            delegator: ALICE.into(),

3361

1

            candidate: ALICE.into(),

3362

1

            target_pool: TargetPool::AutoCompounding,

3363

1

            stake,

3364

1

}],

3365

1

        || {

3366

1

            let at = Session::current_index();

3367

1

            assert_ok!(PooledStaking::request_undelegate(

3368

1

                origin_of(ALICE.into()),

3369

1

                ALICE.into(),

3370

1

                TargetPool::AutoCompounding,

3371

1

                SharesOrStake::Stake(stake),

3372

1

));

3373

3374

1

            run_to_session(4);

3375

1

3376

1

            assert_noop!(

3377

1

                PooledStaking::execute_pending_operations(

3378

1

                    root_origin(),

3379

1

                    vec![PendingOperationQuery {

3380

1

                        delegator: ALICE.into(),

3381

1

                        operation: PendingOperationKey::Leaving {

3382

1

                            candidate: ALICE.into(),

3383

1

at,

3384

1

3385

1

}]

3386

1

),

3387

1

                BadOrigin

3388

1

);

3389

1

},

3390

1

);

3391

1

3392

3393

#[test]

3394

1

fn test_staking_swap() {

3395

1

    setup_staking_join_and_execute(

3396

1

        vec![A {

3397

1

            delegator: ALICE.into(),

3398

1

            candidate: ALICE.into(),

3399

1

            target_pool: TargetPool::AutoCompounding,

3400

1

            stake: 10 * MinimumSelfDelegation::get(),

3401

1

}],

3402

1

        || {

3403

1

            let stake = 10 * MinimumSelfDelegation::get();

3404

1

            assert_ok!(PooledStaking::swap_pool(

3405

1

                origin_of(ALICE.into()),

3406

1

                ALICE.into(),

3407

1

                TargetPool::AutoCompounding,

3408

1

                SharesOrStake::Stake(stake),

3409

1

));

3410

3411

1

            assert_eq!(

3412

1

                PooledStaking::computed_stake(

3413

1

                    ALICE.into(),

3414

1

                    ALICE.into(),

3415

1

                    AllTargetPool::AutoCompounding

3416

1

),

3417

1

                Some(0u32.into())

3418

1

);

3419

1

            assert_eq!(

3420

1

                PooledStaking::computed_stake(

3421

1

                    ALICE.into(),

3422

1

                    ALICE.into(),

3423

1

                    AllTargetPool::ManualRewards

3424

1

),

3425

1

                Some(stake)

3426

1

);

3427

3428

1

            assert_ok!(PooledStaking::swap_pool(

3429

1

                origin_of(ALICE.into()),

3430

1

                ALICE.into(),

3431

1

                TargetPool::ManualRewards,

3432

1

                SharesOrStake::Stake(stake),

3433

1

));

3434

3435

1

            assert_eq!(

3436

1

                PooledStaking::computed_stake(

3437

1

                    ALICE.into(),

3438

1

                    ALICE.into(),

3439

1

                    AllTargetPool::AutoCompounding

3440

1

),

3441

1

                Some(stake)

3442

1

);

3443

1

            assert_eq!(

3444

1

                PooledStaking::computed_stake(

3445

1

                    ALICE.into(),

3446

1

                    ALICE.into(),

3447

1

                    AllTargetPool::ManualRewards

3448

1

),

3449

1

                Some(0u32.into())

3450

1

);

3451

1

},

3452

1

3453

1

3454

3455

#[test]

3456

1

fn test_pallet_session_takes_validators_from_invulnerables_and_staking() {

3457

1

    // Alice, Bob, Charlie are invulnerables

3458

1

    // Alice, Dave are in pallet_staking

3459

1

    // Expected collators are Alice, Bob, Charlie, Dave

3460

1

    ExtBuilder::default()

3461

1

        .with_balances(vec![

3462

1

            // Alice gets 10k extra tokens for her mapping deposit

3463

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3464

1

            (AccountId::from(BOB), 100_000 * UNIT),

3465

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3466

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3467

1

])

3468

1

        .with_collators(vec![

3469

1

            (AccountId::from(ALICE), 210 * UNIT),

3470

1

            (AccountId::from(BOB), 100 * UNIT),

3471

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3472

1

])

3473

1

        .with_para_ids(vec![

3474

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3475

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3476

1

])

3477

1

        .build()

3478

1

        .execute_with(|| {

3479

1

            run_to_block(2);

3480

1

3481

1

            let stake = 10 * MinimumSelfDelegation::get();

3482

1

3483

1

            assert_ok!(PooledStaking::request_delegate(

3484

1

                origin_of(ALICE.into()),

3485

1

                ALICE.into(),

3486

1

                TargetPool::AutoCompounding,

3487

1

                stake,

3488

1

));

3489

3490

            // Register Dave in pallet_session (invulnerables are automatically registered)

3491

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3492

1

            assert_ok!(Session::set_keys(

3493

1

                origin_of(DAVE.into()),

3494

1

                dancebox_runtime::SessionKeys {

3495

1

                    nimbus: dave_account_id,

3496

1

},

3497

1

                vec![]

3498

1

));

3499

3500

1

            assert_ok!(PooledStaking::request_delegate(

3501

1

                origin_of(DAVE.into()),

3502

1

                DAVE.into(),

3503

1

                TargetPool::AutoCompounding,

3504

1

                stake,

3505

1

));

3506

3507

1

            let eligible_candidates =

3508

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3509

1

            assert_eq!(

3510

1

                eligible_candidates,

3511

1

                vec![

3512

1

                    EligibleCandidate {

3513

1

                        candidate: ALICE.into(),

3514

1

                        stake

3515

1

},

3516

1

                    EligibleCandidate {

3517

1

                        candidate: DAVE.into(),

3518

1

                        stake

3519

1

},

3520

1

3521

1

);

3522

3523

1

            assert_eq!(

3524

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3525

1

                vec![

3526

1

                    AccountId::from(ALICE),

3527

1

                    AccountId::from(BOB),

3528

1

                    AccountId::from(CHARLIE),

3529

1

3530

1

);

3531

3532

            // Need to trigger new session to update pallet_session

3533

1

            run_to_session(2);

3534

1

3535

1

            assert_eq!(

3536

1

                Session::validators(),

3537

1

                vec![

3538

1

                    AccountId::from(ALICE),

3539

1

                    AccountId::from(BOB),

3540

1

                    AccountId::from(CHARLIE),

3541

1

                    AccountId::from(DAVE),

3542

1

3543

1

);

3544

1

});

3545

1

3546

3547

#[test]

3548

1

fn test_pallet_session_limits_num_validators() {

3549

1

    // Set max_collators = 2, now only the first 2 invulnerables are valid collators

3550

1

    ExtBuilder::default()

3551

1

        .with_balances(vec![

3552

1

            // Alice gets 10k extra tokens for her mapping deposit

3553

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3554

1

            (AccountId::from(BOB), 100_000 * UNIT),

3555

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3556

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3557

1

])

3558

1

        .with_collators(vec![

3559

1

            (AccountId::from(ALICE), 210 * UNIT),

3560

1

            (AccountId::from(BOB), 100 * UNIT),

3561

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3562

1

])

3563

1

        .with_para_ids(vec![

3564

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3565

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3566

1

])

3567

1

        .with_config(pallet_configuration::HostConfiguration {

3568

1

            max_collators: 2,

3569

1

            min_orchestrator_collators: 2,

3570

1

            max_orchestrator_collators: 2,

3571

1

            collators_per_container: 2,

3572

1

            full_rotation_period: 24,

3573

1

            ..Default::default()

3574

1

})

3575

1

        .build()

3576

1

        .execute_with(|| {

3577

1

            run_to_block(2);

3578

1

3579

1

            let stake = 10 * MinimumSelfDelegation::get();

3580

1

3581

1

            assert_ok!(PooledStaking::request_delegate(

3582

1

                origin_of(ALICE.into()),

3583

1

                ALICE.into(),

3584

1

                TargetPool::AutoCompounding,

3585

1

                stake,

3586

1

));

3587

3588

            // Register Dave in pallet_session (invulnerables are automatically registered)

3589

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3590

1

            assert_ok!(Session::set_keys(

3591

1

                origin_of(DAVE.into()),

3592

1

                dancebox_runtime::SessionKeys {

3593

1

                    nimbus: dave_account_id,

3594

1

},

3595

1

                vec![]

3596

1

));

3597

3598

1

            assert_ok!(PooledStaking::request_delegate(

3599

1

                origin_of(DAVE.into()),

3600

1

                DAVE.into(),

3601

1

                TargetPool::AutoCompounding,

3602

1

                stake,

3603

1

));

3604

3605

1

            let eligible_candidates =

3606

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3607

1

            assert_eq!(

3608

1

                eligible_candidates,

3609

1

                vec![

3610

1

                    EligibleCandidate {

3611

1

                        candidate: ALICE.into(),

3612

1

                        stake

3613

1

},

3614

1

                    EligibleCandidate {

3615

1

                        candidate: DAVE.into(),

3616

1

                        stake

3617

1

},

3618

1

3619

1

);

3620

3621

1

            assert_eq!(

3622

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3623

1

                vec![

3624

1

                    AccountId::from(ALICE),

3625

1

                    AccountId::from(BOB),

3626

1

                    AccountId::from(CHARLIE),

3627

1

3628

1

);

3629

3630

            // Need to trigger new session to update pallet_session

3631

1

            run_to_session(2);

3632

1

3633

1

            assert_eq!(

3634

1

                Session::validators(),

3635

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3636

1

);

3637

1

});

3638

1

3639

3640

#[test]

3641

1

fn test_pallet_session_limits_num_validators_from_staking() {

3642

1

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

3643

1

    ExtBuilder::default()

3644

1

        .with_balances(vec![

3645

1

            // Alice gets 10k extra tokens for her mapping deposit

3646

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3647

1

            (AccountId::from(BOB), 100_000 * UNIT),

3648

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3649

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3650

1

])

3651

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3652

1

        .with_para_ids(vec![

3653

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3654

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3655

1

])

3656

1

        .with_config(pallet_configuration::HostConfiguration {

3657

1

            max_collators: 2,

3658

1

            min_orchestrator_collators: 2,

3659

1

            max_orchestrator_collators: 2,

3660

1

            collators_per_container: 2,

3661

1

            full_rotation_period: 24,

3662

1

            ..Default::default()

3663

1

})

3664

1

        .build()

3665

1

        .execute_with(|| {

3666

1

            run_to_block(2);

3667

1

3668

1

            let stake = 10 * MinimumSelfDelegation::get();

3669

1

3670

1

            // Register accounts in pallet_session (invulnerables are automatically registered)

3671

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

3672

1

            assert_ok!(Session::set_keys(

3673

1

                origin_of(BOB.into()),

3674

1

                dancebox_runtime::SessionKeys {

3675

1

                    nimbus: bob_account_id,

3676

1

},

3677

1

                vec![]

3678

1

));

3679

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

3680

1

            assert_ok!(Session::set_keys(

3681

1

                origin_of(CHARLIE.into()),

3682

1

                dancebox_runtime::SessionKeys {

3683

1

                    nimbus: charlie_account_id,

3684

1

},

3685

1

                vec![]

3686

1

));

3687

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3688

1

            assert_ok!(Session::set_keys(

3689

1

                origin_of(DAVE.into()),

3690

1

                dancebox_runtime::SessionKeys {

3691

1

                    nimbus: dave_account_id,

3692

1

},

3693

1

                vec![]

3694

1

));

3695

3696

1

            assert_ok!(PooledStaking::request_delegate(

3697

1

                origin_of(BOB.into()),

3698

1

                BOB.into(),

3699

1

                TargetPool::AutoCompounding,

3700

1

                stake,

3701

1

));

3702

3703

1

            assert_ok!(PooledStaking::request_delegate(

3704

1

                origin_of(CHARLIE.into()),

3705

1

                CHARLIE.into(),

3706

1

                TargetPool::AutoCompounding,

3707

1

                stake,

3708

1

));

3709

3710

1

            assert_ok!(PooledStaking::request_delegate(

3711

1

                origin_of(DAVE.into()),

3712

1

                DAVE.into(),

3713

1

                TargetPool::AutoCompounding,

3714

1

                stake,

3715

1

));

3716

3717

1

            let eligible_candidates =

3718

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

3719

1

            assert_eq!(

3720

1

                eligible_candidates,

3721

1

                vec![

3722

1

                    EligibleCandidate {

3723

1

                        candidate: BOB.into(),

3724

1

                        stake

3725

1

},

3726

1

                    EligibleCandidate {

3727

1

                        candidate: CHARLIE.into(),

3728

1

                        stake

3729

1

},

3730

1

                    EligibleCandidate {

3731

1

                        candidate: DAVE.into(),

3732

1

                        stake

3733

1

},

3734

1

3735

1

);

3736

3737

1

            assert_eq!(

3738

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

3739

1

                vec![AccountId::from(ALICE),]

3740

1

);

3741

3742

            // Need to trigger new session to update pallet_session

3743

1

            run_to_session(2);

3744

1

3745

1

            assert_eq!(

3746

1

                Session::validators(),

3747

1

                vec![AccountId::from(ALICE), AccountId::from(BOB),]

3748

1

);

3749

1

});

3750

1

3751

3752

#[test]

3753

1

fn test_reward_to_staking_candidate() {

3754

1

    // Alice, Bob, Charlie are invulnerables

3755

1

    ExtBuilder::default()

3756

1

        .with_balances(vec![

3757

1

            // Alice gets 10k extra tokens for her mapping deposit

3758

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3759

1

            (AccountId::from(BOB), 100_000 * UNIT),

3760

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3761

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3762

1

])

3763

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3764

1

        .with_para_ids(vec![

3765

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3766

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3767

1

])

3768

1

        .build()

3769

1

        .execute_with(|| {

3770

1

            run_to_block(2);

3771

1

3772

1

            let dave_account_id = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3773

1

            assert_ok!(Session::set_keys(

3774

1

                origin_of(DAVE.into()),

3775

1

                dancebox_runtime::SessionKeys {

3776

1

                    nimbus: dave_account_id,

3777

1

},

3778

1

                vec![]

3779

1

));

3780

3781

            // We make delegations to DAVE so that she is an elligible candidate.

3782

3783

1

            let stake = 10 * MinimumSelfDelegation::get();

3784

1

3785

1

            assert_ok!(PooledStaking::request_delegate(

3786

1

                origin_of(DAVE.into()),

3787

1

                DAVE.into(),

3788

1

                TargetPool::ManualRewards,

3789

1

                stake,

3790

1

));

3791

1

            assert_ok!(PooledStaking::request_delegate(

3792

1

                origin_of(BOB.into()),

3793

1

                DAVE.into(),

3794

1

                TargetPool::AutoCompounding,

3795

1

                stake,

3796

1

));

3797

3798

            // wait few sessions for the request to be executable

3799

1

            run_to_session(3u32);

3800

1

            assert_ok!(PooledStaking::execute_pending_operations(

3801

1

                origin_of(ALICE.into()),

3802

1

                vec![

3803

1

                    PendingOperationQuery {

3804

1

                        delegator: DAVE.into(),

3805

1

                        operation: PendingOperationKey::JoiningManualRewards {

3806

1

                            candidate: DAVE.into(),

3807

1

                            at: 0

3808

1

3809

1

},

3810

1

                    PendingOperationQuery {

3811

1

                        delegator: BOB.into(),

3812

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3813

1

                            candidate: DAVE.into(),

3814

1

                            at: 0

3815

1

3816

1

3817

1

3818

1

));

3819

3820

            // wait for next session so that DAVE is elected

3821

1

            run_to_session(4u32);

3822

1

3823

1

            assert_eq!(

3824

1

                Session::validators(),

3825

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

3826

1

);

3827

3828

1

            let account: AccountId = DAVE.into();

3829

1

            let balance_before = System::account(account.clone()).data.free;

3830

1

            let summary = (0..100)

3831

1

                .find_map(|_| {

3832

1

                    let summary = run_block();

3833

1

                    if summary.author_id == DAVE.into() {

3834

1

                        Some(summary)

3835

                    } else {

3836

                        None

3837

3838

1

})

3839

1

                .unwrap_or_else(|| panic!("DAVE doesn't seem to author any blocks"));

3840

1

            let balance_after = System::account(account).data.free;

3841

1

3842

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3843

1

            // rewards are shared between orchestrator and registered paras

3844

1

            let orchestrator_rewards = all_rewards / 3;

3845

1

            let candidate_rewards = RewardsCollatorCommission::get() * orchestrator_rewards;

3846

1

3847

1

            assert_eq!(

3848

1

                candidate_rewards,

3849

1

                balance_after - balance_before,

3850

                "dave should get the correct reward portion"

3851

);

3852

1

});

3853

1

3854

3855

#[test]

3856

1

fn test_reward_to_invulnerable() {

3857

1

    // Alice, Bob, Charlie are invulnerables

3858

1

    ExtBuilder::default()

3859

1

        .with_balances(vec![

3860

1

            // Alice gets 10k extra tokens for her mapping deposit

3861

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3862

1

            (AccountId::from(BOB), 100_000 * UNIT),

3863

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3864

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3865

1

])

3866

1

        .with_collators(vec![

3867

1

            (AccountId::from(ALICE), 210 * UNIT),

3868

1

            (AccountId::from(BOB), 100 * UNIT),

3869

1

            (AccountId::from(CHARLIE), 100 * UNIT),

3870

1

])

3871

1

        .with_para_ids(vec![

3872

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3873

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3874

1

])

3875

1

        .build()

3876

1

        .execute_with(|| {

3877

1

            run_to_block(2);

3878

1

3879

1

            // We make delegations to ALICE so that she is an elligible candidate.

3880

1

            // However since she is an invulnerable she should get all the

3881

1

            // rewards.

3882

1

3883

1

            let stake = 10 * MinimumSelfDelegation::get();

3884

1

3885

1

            assert_ok!(PooledStaking::request_delegate(

3886

1

                origin_of(ALICE.into()),

3887

1

                ALICE.into(),

3888

1

                TargetPool::ManualRewards,

3889

1

                stake,

3890

1

));

3891

1

            assert_ok!(PooledStaking::request_delegate(

3892

1

                origin_of(BOB.into()),

3893

1

                ALICE.into(),

3894

1

                TargetPool::AutoCompounding,

3895

1

                stake,

3896

1

));

3897

3898

            // wait few sessions for the request to be executable

3899

1

            run_to_session(3u32);

3900

1

            assert_ok!(PooledStaking::execute_pending_operations(

3901

1

                origin_of(ALICE.into()),

3902

1

                vec![

3903

1

                    PendingOperationQuery {

3904

1

                        delegator: ALICE.into(),

3905

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3906

1

                            candidate: ALICE.into(),

3907

1

                            at: 0

3908

1

3909

1

},

3910

1

                    PendingOperationQuery {

3911

1

                        delegator: BOB.into(),

3912

1

                        operation: PendingOperationKey::JoiningAutoCompounding {

3913

1

                            candidate: ALICE.into(),

3914

1

                            at: 0

3915

1

3916

1

3917

1

3918

1

));

3919

3920

            // wait for next session so that ALICE is elected

3921

1

            run_to_session(4u32);

3922

1

3923

1

            let account: AccountId = ALICE.into();

3924

1

            let balance_before = System::account(account.clone()).data.free;

3925

1

3926

1

            let summary = (0..100)

3927

2

                .find_map(|_| {

3928

2

                    let summary = run_block();

3929

2

                    if summary.author_id == ALICE.into() {

3930

1

                        Some(summary)

3931

                    } else {

3932

1

                        None

3933

3934

2

})

3935

1

                .unwrap_or_else(|| panic!("ALICE doesn't seem to author any blocks"));

3936

1

3937

1

            let balance_after = System::account(account).data.free;

3938

1

3939

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3940

1

            // rewards are shared between orchestrator and registered paras

3941

1

            let orchestrator_rewards = all_rewards / 3;

3942

1

            assert_eq!(

3943

1

                orchestrator_rewards,

3944

1

                balance_after - balance_before,

3945

                "alice should get the correct reward portion"

3946

);

3947

1

});

3948

1

3949

3950

#[test]

3951

1

fn test_reward_to_invulnerable_with_key_change() {

3952

1

    ExtBuilder::default()

3953

1

        .with_balances(vec![

3954

1

            // Alice gets 10k extra tokens for her mapping deposit

3955

1

            (AccountId::from(ALICE), 210_000 * UNIT),

3956

1

            (AccountId::from(BOB), 100_000 * UNIT),

3957

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

3958

1

            (AccountId::from(DAVE), 100_000 * UNIT),

3959

1

])

3960

1

        .with_collators(vec![(AccountId::from(ALICE), 210 * UNIT)])

3961

1

        .with_para_ids(vec![

3962

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3963

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

3964

1

])

3965

1

        .build()

3966

1

        .execute_with(|| {

3967

1

            run_to_block(2);

3968

1

3969

1

            run_to_session(2u32);

3970

1

3971

1

            // change key, this should be reflected 2 sessions afterward

3972

1

            let alice_new_key = get_aura_id_from_seed(&AccountId::from(DAVE).to_string());

3973

1

            assert_ok!(Session::set_keys(

3974

1

                origin_of(ALICE.into()),

3975

1

                dancebox_runtime::SessionKeys {

3976

1

                    nimbus: alice_new_key,

3977

1

},

3978

1

                vec![]

3979

1

));

3980

3981

1

            run_to_session(4u32);

3982

1

3983

1

            let account: AccountId = ALICE.into();

3984

1

            let balance_before = System::account(account.clone()).data.free;

3985

1

3986

1

            let summary = run_block();

3987

1

            assert_eq!(summary.author_id, ALICE.into());

3988

3989

1

            let balance_after = System::account(account).data.free;

3990

1

3991

1

            let all_rewards = RewardsPortion::get() * summary.inflation;

3992

1

            // rewards are shared between orchestrator and registered paras

3993

1

            let orchestrator_rewards = all_rewards / 3;

3994

1

            assert_eq!(

3995

1

                orchestrator_rewards,

3996

1

                balance_after - balance_before,

3997

                "alice should get the correct reward portion"

3998

);

3999

1

});

4000

1

4001

4002

#[test]

4003

1

fn test_migration_config_full_rotation_period() {

4004

1

    ExtBuilder::default()

4005

1

        .build()

4006

1

        .execute_with(|| {

4007

1

            const CONFIGURATION_ACTIVE_CONFIG_KEY: &[u8] =

4008

1

                &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385");

4009

1

            const CONFIGURATION_PENDING_CONFIGS_KEY: &[u8] =

4010

1

                &hex_literal::hex!("06de3d8a54d27e44a9d5ce189618f22d53b4123b2e186e07fb7bad5dda5f55c0");

4011

1

4012

1

            // Modify active config

4013

1

            frame_support::storage::unhashed::put_raw(CONFIGURATION_ACTIVE_CONFIG_KEY, &hex_literal::hex!("6300000002000000050000000200000000000000"));

4014

1

            // Modify pending configs

4015

1

            frame_support::storage::unhashed::put_raw(CONFIGURATION_PENDING_CONFIGS_KEY, &hex_literal::hex!("08b10800006300000002000000050000000200000000000000b20800006400000002000000050000000200000000000000"));

4016

1

4017

1

            let migration = MigrateConfigurationParathreads::<Runtime>(Default::default());

4018

1

            migration.migrate(Default::default());

4019

1

4020

1

            let expected_active = pallet_configuration::HostConfiguration {

4021

1

                max_collators: 99,

4022

1

                min_orchestrator_collators: 2,

4023

1

                max_orchestrator_collators: 5,

4024

1

                collators_per_container: 2,

4025

1

                full_rotation_period: 0,

4026

1

                ..Default::default()

4027

1

};

4028

1

            assert_eq!(Configuration::config(), expected_active);

4029

4030

1

            let expected_pending = vec![

4031

1

4032

1

                    2225,

4033

1

                    pallet_configuration::HostConfiguration {

4034

1

                        max_collators: 99,

4035

1

                        min_orchestrator_collators: 2,

4036

1

                        max_orchestrator_collators: 5,

4037

1

                        collators_per_container: 2,

4038

1

                        full_rotation_period: 0,

4039

1

                        ..Default::default()

4040

1

},

4041

1

),

4042

1

4043

1

                    2226,

4044

1

                    pallet_configuration::HostConfiguration {

4045

1

                        max_collators: 100,

4046

1

                        min_orchestrator_collators: 2,

4047

1

                        max_orchestrator_collators: 5,

4048

1

                        collators_per_container: 2,

4049

1

                        full_rotation_period: 0,

4050

1

                        ..Default::default()

4051

1

},

4052

1

),

4053

1

];

4054

1

            assert_eq!(Configuration::pending_configs(), expected_pending);

4055

1

});

4056

1

4057

4058

#[test]

4059

1

fn test_migration_registrar_pending_verification() {

4060

1

    ExtBuilder::default().build().execute_with(|| {

4061

1

        const REGISTRAR_PENDING_VERIFICATION_KEY: &[u8] =

4062

1

            &hex_literal::hex!("3fba98689ebed1138735e0e7a5a790ab57a35de516113188134ad8e43c6d55ec");

4063

1

4064

1

        // Modify active config

4065

1

        let para_ids: Vec<ParaId> = vec![2000.into(), 2001.into(), 2002.into(), 3000.into()];

4066

1

        frame_support::storage::unhashed::put(REGISTRAR_PENDING_VERIFICATION_KEY, &para_ids);

4067

1

4068

1

        let migration = RegistrarPendingVerificationValueToMap::<Runtime>(Default::default());

4069

1

        migration.migrate(Default::default());

4070

1

4071

1

        let empty_key =

4072

1

            frame_support::storage::unhashed::get_raw(REGISTRAR_PENDING_VERIFICATION_KEY);

4073

1

        assert_eq!(empty_key, None);

4074

4075

5

        for para_id in para_ids {

4076

4

            let exists_in_map =

4077

4

                pallet_registrar::PendingVerification::<Runtime>::get(para_id).is_some();

4078

4

            assert!(

4079

4

                exists_in_map,

4080

                "After migration, para id {:?} does not exist in storage map",

4081

                para_id

4082

);

4083

4084

1

});

4085

1

4086

4087

#[test]

4088

1

fn test_collator_assignment_gives_priority_to_invulnerables() {

4089

1

    // Set max_collators = 2, take 1 invulnerable and the rest from staking

4090

1

    ExtBuilder::default()

4091

1

        .with_balances(vec![

4092

1

            // Alice gets 10k extra tokens for her mapping deposit

4093

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4094

1

            (AccountId::from(BOB), 100_000 * UNIT),

4095

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4096

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4097

1

])

4098

1

        .with_collators(vec![

4099

1

            (AccountId::from(ALICE), 210 * UNIT),

4100

1

            (AccountId::from(DAVE), 100 * UNIT),

4101

1

])

4102

1

        .with_para_ids(vec![

4103

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

4104

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

4105

1

])

4106

1

        .build()

4107

1

        .execute_with(|| {

4108

1

            run_to_block(2);

4109

1

4110

1

            let stake = 10 * MinimumSelfDelegation::get();

4111

1

4112

1

            // Register accounts in pallet_session (invulnerables are automatically registered)

4113

1

            let bob_account_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4114

1

            assert_ok!(Session::set_keys(

4115

1

                origin_of(BOB.into()),

4116

1

                dancebox_runtime::SessionKeys {

4117

1

                    nimbus: bob_account_id,

4118

1

},

4119

1

                vec![]

4120

1

));

4121

1

            let charlie_account_id = get_aura_id_from_seed(&AccountId::from(CHARLIE).to_string());

4122

1

            assert_ok!(Session::set_keys(

4123

1

                origin_of(CHARLIE.into()),

4124

1

                dancebox_runtime::SessionKeys {

4125

1

                    nimbus: charlie_account_id,

4126

1

},

4127

1

                vec![]

4128

1

));

4129

4130

1

            assert_ok!(PooledStaking::request_delegate(

4131

1

                origin_of(BOB.into()),

4132

1

                BOB.into(),

4133

1

                TargetPool::AutoCompounding,

4134

1

                stake,

4135

1

));

4136

1

            assert_ok!(PooledStaking::request_delegate(

4137

1

                origin_of(CHARLIE.into()),

4138

1

                CHARLIE.into(),

4139

1

                TargetPool::AutoCompounding,

4140

1

                stake,

4141

1

));

4142

4143

1

            let eligible_candidates =

4144

1

                pallet_pooled_staking::SortedEligibleCandidates::<Runtime>::get().to_vec();

4145

1

            assert_eq!(

4146

1

                eligible_candidates,

4147

1

                vec![

4148

1

                    EligibleCandidate {

4149

1

                        candidate: BOB.into(),

4150

1

                        stake

4151

1

},

4152

1

                    EligibleCandidate {

4153

1

                        candidate: CHARLIE.into(),

4154

1

                        stake

4155

1

},

4156

1

4157

1

);

4158

4159

1

            assert_eq!(

4160

1

                pallet_invulnerables::Invulnerables::<Runtime>::get().to_vec(),

4161

1

                vec![AccountId::from(ALICE), AccountId::from(DAVE)]

4162

1

);

4163

4164

1

            set_parachain_inherent_data_random_seed([1; 32]);

4165

1

            run_block();

4166

1

4167

1

            // Need to trigger new session to update pallet_session

4168

1

            run_to_session(2);

4169

1

4170

1

            assert_eq!(

4171

1

                Session::validators(),

4172

1

                vec![

4173

1

                    AccountId::from(ALICE),

4174

1

                    AccountId::from(DAVE),

4175

1

                    AccountId::from(BOB),

4176

1

                    AccountId::from(CHARLIE)

4177

1

4178

1

);

4179

4180

            // Need to trigger full rotation to ensure invulnerables are assigned

4181

1

            let rotation_period = Configuration::config().full_rotation_period;

4182

1

            run_to_session(rotation_period);

4183

1

4184

1

            assert!(

4185

1

                CollatorAssignment::collator_container_chain()

4186

1

                    .orchestrator_chain

4187

1

                    .contains(&AccountId::from(ALICE)),

4188

                "CollatorAssignment did not give priority to invulnerable ALICE: {:?}",

4189

                CollatorAssignment::collator_container_chain()

4190

);

4191

4192

1

            assert!(

4193

1

                CollatorAssignment::collator_container_chain()

4194

1

                    .orchestrator_chain

4195

1

                    .contains(&AccountId::from(DAVE)),

4196

                "CollatorAssignment did not give priority to invulnerable DAVE: {:?}",

4197

                CollatorAssignment::collator_container_chain()

4198

);

4199

1

});

4200

1

4201

4202

#[test]

4203

1

fn test_can_buy_credits_before_registering_para() {

4204

1

    ExtBuilder::default()

4205

1

        .with_balances(vec![

4206

1

            // Alice gets 10k extra tokens for her mapping deposit

4207

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4208

1

            (AccountId::from(BOB), 100_000 * UNIT),

4209

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4210

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4211

1

])

4212

1

        .with_collators(vec![

4213

1

            (AccountId::from(ALICE), 210 * UNIT),

4214

1

            (AccountId::from(BOB), 100 * UNIT),

4215

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4216

1

            (AccountId::from(DAVE), 100 * UNIT),

4217

1

])

4218

1

        .build()

4219

1

        .execute_with(|| {

4220

1

            run_to_block(2);

4221

1

4222

1

            // Try to buy the maximum amount of credits

4223

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4224

1

4225

1

            assert_ok!(ServicesPayment::purchase_credits(

4226

1

                origin_of(ALICE.into()),

4227

1

                1001.into(),

4228

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4229

1

));

4230

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4231

1

4232

1

            // Now parachain tank should have this amount

4233

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4234

1

                .data

4235

1

                .free;

4236

1

4237

1

            assert_eq!(

4238

1

                balance_tank,

4239

1

                block_credits_to_required_balance(u32::MAX, 1001.into())

4240

1

);

4241

4242

1

            let expected_cost = block_credits_to_required_balance(u32::MAX, 1001.into());

4243

1

            assert_eq!(balance_before - balance_after, expected_cost);

4244

1

});

4245

1

4246

4247

#[test]

4248

1

fn test_cannot_mark_valid_para_with_no_bootnodes() {

4249

1

    ExtBuilder::default()

4250

1

        .with_balances(vec![

4251

1

            // Alice gets 10k extra tokens for her mapping deposit

4252

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4253

1

            (AccountId::from(BOB), 100_000 * UNIT),

4254

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4255

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4256

1

])

4257

1

        .with_collators(vec![

4258

1

            (AccountId::from(ALICE), 210 * UNIT),

4259

1

            (AccountId::from(BOB), 100 * UNIT),

4260

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4261

1

            (AccountId::from(DAVE), 100 * UNIT),

4262

1

])

4263

1

        .build()

4264

1

        .execute_with(|| {

4265

1

            run_to_block(2);

4266

1

            assert_ok!(Registrar::register(

4267

1

                origin_of(ALICE.into()),

4268

1

                1001.into(),

4269

1

                empty_genesis_data()

4270

1

));

4271

1

            assert_noop!(

4272

1

                Registrar::mark_valid_for_collating(root_origin(), 1001.into()),

4273

1

                pallet_data_preservers::Error::<Runtime>::NoBootNodes,

4274

1

);

4275

1

});

4276

1

4277

4278

#[test]

4279

1

fn test_can_buy_credits_before_registering_para_and_receive_free_credits() {

4280

1

    ExtBuilder::default()

4281

1

        .with_balances(vec![

4282

1

            // Alice gets 10k extra tokens for her mapping deposit

4283

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4284

1

            (AccountId::from(BOB), 100_000 * UNIT),

4285

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4286

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4287

1

])

4288

1

        .with_collators(vec![

4289

1

            (AccountId::from(ALICE), 210 * UNIT),

4290

1

            (AccountId::from(BOB), 100 * UNIT),

4291

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4292

1

            (AccountId::from(DAVE), 100 * UNIT),

4293

1

])

4294

1

        .build()

4295

1

        .execute_with(|| {

4296

1

            run_to_block(2);

4297

1

4298

1

            // Try to buy (MaxCreditsStored - 1) credits

4299

1

            let balance_before = System::account(AccountId::from(ALICE)).data.free;

4300

1

            assert_ok!(ServicesPayment::purchase_credits(

4301

1

                origin_of(ALICE.into()),

4302

1

                1001.into(),

4303

1

                block_credits_to_required_balance(

4304

1

                    dancebox_runtime::FreeBlockProductionCredits::get() - 1,

4305

1

                    1001.into()

4306

1

4307

1

));

4308

1

            let balance_after = System::account(AccountId::from(ALICE)).data.free;

4309

1

4310

1

            // Now parachain tank should have this amount

4311

1

            let balance_tank = System::account(ServicesPayment::parachain_tank(1001.into()))

4312

1

                .data

4313

1

                .free;

4314

1

4315

1

            assert_eq!(

4316

1

                balance_tank,

4317

1

                block_credits_to_required_balance(

4318

1

                    dancebox_runtime::FreeBlockProductionCredits::get() - 1,

4319

1

                    1001.into()

4320

1

4321

1

);

4322

4323

1

            let expected_cost = block_credits_to_required_balance(

4324

1

                dancebox_runtime::FreeBlockProductionCredits::get() - 1,

4325

1

                1001.into(),

4326

1

);

4327

1

            assert_eq!(balance_before - balance_after, expected_cost);

4328

4329

            // Now register para

4330

1

            assert_ok!(Registrar::register(

4331

1

                origin_of(ALICE.into()),

4332

1

                1001.into(),

4333

1

                empty_genesis_data()

4334

1

));

4335

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4336

1

            assert_ok!(Registrar::mark_valid_for_collating(

4337

1

                root_origin(),

4338

1

                1001.into()

4339

1

));

4340

4341

            // We received aññ free credits, because we cannot have more than MaxCreditsStored

4342

1

            let credits =

4343

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4344

1

                    .unwrap_or_default();

4345

1

            assert_eq!(credits, dancebox_runtime::FreeBlockProductionCredits::get());

4346

1

});

4347

1

4348

4349

#[test]

4350

1

fn test_deregister_and_register_again_does_not_give_free_credits() {

4351

1

    ExtBuilder::default()

4352

1

        .with_balances(vec![

4353

1

            // Alice gets 10k extra tokens for her mapping deposit

4354

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4355

1

            (AccountId::from(BOB), 100_000 * UNIT),

4356

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4357

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4358

1

])

4359

1

        .with_collators(vec![

4360

1

            (AccountId::from(ALICE), 210 * UNIT),

4361

1

            (AccountId::from(BOB), 100 * UNIT),

4362

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4363

1

            (AccountId::from(DAVE), 100 * UNIT),

4364

1

])

4365

1

        .build()

4366

1

        .execute_with(|| {

4367

1

            run_to_block(2);

4368

1

4369

1

            // Register

4370

1

            assert_ok!(Registrar::register(

4371

1

                origin_of(ALICE.into()),

4372

1

                1001.into(),

4373

1

                empty_genesis_data()

4374

1

            ),);

4375

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4376

1

            assert_ok!(Registrar::mark_valid_for_collating(

4377

1

                root_origin(),

4378

1

                1001.into()

4379

1

            ),);

4380

            // We received free credits

4381

1

            let credits =

4382

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4383

1

                    .unwrap_or_default();

4384

1

            assert_eq!(credits, dancebox_runtime::FreeBlockProductionCredits::get());

4385

            // Deregister after 1 session

4386

1

            run_to_session(1);

4387

1

            assert_ok!(Registrar::deregister(root_origin(), 1001.into()), ());

4388

4389

1

            run_to_session(3);

4390

1

            let credits_before_2nd_register =

4391

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4392

1

                    .unwrap_or_default();

4393

1

            // We spent some credits because this container chain had collators for 1 session

4394

1

            assert_ne!(

4395

1

                credits_before_2nd_register,

4396

1

                dancebox_runtime::FreeBlockProductionCredits::get()

4397

1

);

4398

            // Register again

4399

1

            assert_ok!(Registrar::register(

4400

1

                origin_of(ALICE.into()),

4401

1

                1001.into(),

4402

1

                empty_genesis_data()

4403

1

            ),);

4404

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4405

1

            assert_ok!(Registrar::mark_valid_for_collating(

4406

1

                root_origin(),

4407

1

                1001.into()

4408

1

            ),);

4409

            // No more free credits

4410

1

            let credits =

4411

1

                pallet_services_payment::BlockProductionCredits::<Runtime>::get(ParaId::from(1001))

4412

1

                    .unwrap_or_default();

4413

1

            assert_eq!(credits, credits_before_2nd_register);

4414

1

});

4415

1

4416

4417

#[test]

4418

1

fn test_sudo_can_register_foreign_assets_and_manager_change_paremeters() {

4419

1

    ExtBuilder::default()

4420

1

        .with_balances(vec![

4421

1

            // Alice gets 10k extra tokens for her mapping deposit

4422

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4423

1

            (AccountId::from(BOB), 100_000 * UNIT),

4424

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4425

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4426

1

])

4427

1

        .with_collators(vec![

4428

1

            (AccountId::from(ALICE), 210 * UNIT),

4429

1

            (AccountId::from(BOB), 100 * UNIT),

4430

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4431

1

            (AccountId::from(DAVE), 100 * UNIT),

4432

1

])

4433

1

4434

1

        .build()

4435

1

        .execute_with(|| {

4436

1

4437

1

            // We register the asset with Alice as manager

4438

1

            assert_ok!(ForeignAssetsCreator::create_foreign_asset(root_origin(), Location::parent(), 1, AccountId::from(ALICE), true, 1), ());

4439

1

            assert_eq!(ForeignAssetsCreator::foreign_asset_for_id(1), Some(Location::parent()));

4440

1

            assert_eq!(ForeignAssetsCreator::asset_id_for_foreign(Location::parent()), Some(1));

4441

4442

            // Alice now can change parameters like metadata from the asset

4443

1

            assert_ok!(ForeignAssets::set_metadata(origin_of(ALICE.into()), 1, b"xcDot".to_vec(), b"xcDot".to_vec(), 12));

4444

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::name(1),  b"xcDot".to_vec());

4445

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::symbol(1),  b"xcDot".to_vec());

4446

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::metadata::Inspect<AccountId>>::decimals(1),  12);

4447

4448

            // Any other person cannot do this

4449

1

            assert_noop!(

4450

1

                ForeignAssets::set_metadata(origin_of(BOB.into()), 1, b"dummy".to_vec(), b"dummy".to_vec(), 12),

4451

1

                pallet_assets::Error::<Runtime, Instance1>::NoPermission

4452

1

);

4453

4454

            // Alice now can mint

4455

1

            assert_ok!(ForeignAssets::mint(origin_of(ALICE.into()), 1, AccountId::from(BOB).into(), 1000));

4456

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::total_issuance(1),  1000);

4457

1

            assert_eq!(<ForeignAssets as frame_support::traits::fungibles::Inspect<AccountId>>::balance(1, &AccountId::from(BOB)),  1000);

4458

1

});

4459

1

4460

4461

#[test]

4462

1

fn test_assets_cannot_be_created_from_signed_origins() {

4463

1

    ExtBuilder::default()

4464

1

        .with_balances(vec![

4465

1

            // Alice gets 10k extra tokens for her mapping deposit

4466

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4467

1

            (AccountId::from(BOB), 100_000 * UNIT),

4468

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4469

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4470

1

])

4471

1

        .with_collators(vec![

4472

1

            (AccountId::from(ALICE), 210 * UNIT),

4473

1

            (AccountId::from(BOB), 100 * UNIT),

4474

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4475

1

            (AccountId::from(DAVE), 100 * UNIT),

4476

1

])

4477

1

        .build()

4478

1

        .execute_with(|| {

4479

1

            // We try to register the asset with Alice as origin

4480

1

            // Any other person cannot do this

4481

1

            assert_noop!(

4482

1

                ForeignAssetsCreator::create_foreign_asset(

4483

1

                    origin_of(ALICE.into()),

4484

1

                    Location::parent(),

4485

1

1,

4486

1

                    AccountId::from(ALICE),

4487

1

                    true,

4488

1

4489

1

),

4490

1

                BadOrigin

4491

1

);

4492

4493

1

            assert_noop!(

4494

1

                ForeignAssets::create(origin_of(ALICE.into()), 1, AccountId::from(ALICE).into(), 1),

4495

1

                BadOrigin

4496

1

);

4497

1

});

4498

1

4499

4500

#[test]

4501

1

fn test_asset_rate_can_be_set_from_sudo_but_not_from_signed() {

4502

1

    ExtBuilder::default()

4503

1

        .with_balances(vec![

4504

1

            // Alice gets 10k extra tokens for her mapping deposit

4505

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4506

1

            (AccountId::from(BOB), 100_000 * UNIT),

4507

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4508

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4509

1

])

4510

1

        .with_collators(vec![

4511

1

            (AccountId::from(ALICE), 210 * UNIT),

4512

1

            (AccountId::from(BOB), 100 * UNIT),

4513

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4514

1

            (AccountId::from(DAVE), 100 * UNIT),

4515

1

])

4516

1

        .build()

4517

1

        .execute_with(|| {

4518

1

            // We try to set the rate from non-sudo

4519

1

            assert_noop!(

4520

1

                AssetRate::create(origin_of(ALICE.into()), Box::new(1), FixedU128::from_u32(1)),

4521

1

                BadOrigin

4522

1

);

4523

4524

            // We try to set the rate from sudo

4525

1

            assert_ok!(AssetRate::create(

4526

1

                root_origin(),

4527

1

                Box::new(1),

4528

1

                FixedU128::from_u32(1)

4529

1

));

4530

4531

1

            assert_eq!(

4532

1

                pallet_asset_rate::ConversionRateToNative::<Runtime>::get(1),

4533

1

                Some(FixedU128::from_u32(1))

4534

1

);

4535

1

});

4536

1

4537

4538

#[test]

4539

1

fn test_division_by_0() {

4540

1

    ExtBuilder::default()

4541

1

        .with_balances(vec![

4542

1

            // Alice gets 10k extra tokens for her mapping deposit

4543

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4544

1

            (AccountId::from(BOB), 100_000 * UNIT),

4545

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4546

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4547

1

])

4548

1

        .with_collators(vec![

4549

1

            (AccountId::from(ALICE), 210 * UNIT),

4550

1

            (AccountId::from(BOB), 100 * UNIT),

4551

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4552

1

            (AccountId::from(DAVE), 100 * UNIT),

4553

1

])

4554

1

        .build()

4555

1

        .execute_with(|| {

4556

1

            // We try to set 0 rate to make sure we dont overflow

4557

1

            assert_ok!(AssetRate::create(

4558

1

                root_origin(),

4559

1

                Box::new(1),

4560

1

                FixedU128::from_u32(0)

4561

1

));

4562

4563

            use frame_support::traits::tokens::ConversionToAssetBalance;

4564

1

            let balance = AssetRate::to_asset_balance(1, 1);

4565

1

            assert!(balance.is_err());

4566

1

});

4567

1

4568

4569

#[test]

4570

1

fn test_register_parathread() {

4571

1

    ExtBuilder::default()

4572

1

        .with_balances(vec![

4573

1

            // Alice gets 10k extra tokens for her mapping deposit

4574

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4575

1

            (AccountId::from(BOB), 100_000 * UNIT),

4576

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4577

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4578

1

])

4579

1

        .with_collators(vec![

4580

1

            (AccountId::from(ALICE), 210 * UNIT),

4581

1

            (AccountId::from(BOB), 100 * UNIT),

4582

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4583

1

            (AccountId::from(DAVE), 100 * UNIT),

4584

1

])

4585

1

        .build()

4586

1

        .execute_with(|| {

4587

1

            run_to_block(2);

4588

1

4589

1

            // Register

4590

1

            assert_ok!(Registrar::register_parathread(

4591

1

                origin_of(ALICE.into()),

4592

1

                3001.into(),

4593

1

                SlotFrequency { min: 1, max: 1 },

4594

1

                empty_genesis_data()

4595

1

));

4596

1

            set_dummy_boot_node(origin_of(ALICE.into()), 3001.into());

4597

1

            assert_ok!(Registrar::mark_valid_for_collating(

4598

1

                root_origin(),

4599

1

                3001.into()

4600

1

));

4601

4602

1

            run_to_session(2);

4603

1

            let assignment = CollatorAssignment::collator_container_chain();

4604

1

            assert_eq!(

4605

1

                assignment.container_chains[&ParaId::from(3001)],

4606

1

                vec![CHARLIE.into()]

4607

1

);

4608

1

});

4609

1

4610

4611

#[test]

4612

1

fn test_ed_plus_block_credit_session_purchase_works() {

4613

1

    ExtBuilder::default()

4614

1

        .with_balances(vec![

4615

1

            // Alice gets 10k extra tokens for her mapping deposit

4616

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4617

1

            (AccountId::from(BOB), 100_000 * UNIT),

4618

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4619

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4620

1

])

4621

1

        .with_collators(vec![

4622

1

            (AccountId::from(ALICE), 210 * UNIT),

4623

1

            (AccountId::from(BOB), 100 * UNIT),

4624

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4625

1

            (AccountId::from(DAVE), 100 * UNIT),

4626

1

])

4627

1

        .build()

4628

1

        .execute_with(|| {

4629

1

            run_to_block(2);

4630

1

            // Assert current slot gets updated

4631

1

            assert_eq!(current_slot(), 1u64);

4632

1

            assert!(current_author() == AccountId::from(BOB));

4633

4634

            // Alice and Bob collate in our chain

4635

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4636

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4637

1

4638

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4639

4640

1

            assert_ok!(Registrar::register(

4641

1

                origin_of(ALICE.into()),

4642

1

                1001.into(),

4643

1

                empty_genesis_data()

4644

1

));

4645

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4646

1

            assert_ok!(Registrar::mark_valid_for_collating(

4647

1

                root_origin(),

4648

1

                1001.into()

4649

1

));

4650

            // Need to reset credits to 0 because now parachains are given free credits on register

4651

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4652

1

                root_origin(),

4653

1

                1001.into(),

4654

1

4655

1

));

4656

1

            let credits_1001 =

4657

1

                block_credits_to_required_balance(dancebox_runtime::Period::get(), 1001.into())

4658

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT;

4659

1

4660

1

            // Fill the tank

4661

1

            assert_ok!(ServicesPayment::purchase_credits(

4662

1

                origin_of(ALICE.into()),

4663

1

                1001.into(),

4664

1

                credits_1001

4665

1

));

4666

4667

            // Assignment should happen after 2 sessions

4668

1

            run_to_session(1u32);

4669

1

            let assignment = CollatorAssignment::collator_container_chain();

4670

1

            assert!(assignment.container_chains.is_empty());

4671

1

            run_to_session(2u32);

4672

1

            // Charlie and Dave should be assigned to para 1001

4673

1

            let assignment = CollatorAssignment::collator_container_chain();

4674

1

            assert_eq!(

4675

1

                assignment.container_chains[&1001u32.into()],

4676

1

                vec![CHARLIE.into(), DAVE.into()]

4677

1

);

4678

4679

            // Simulate block inclusion from container chain 1001

4680

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4681

1

            let slot: u64 = 5;

4682

1

            let s = ParaHeaderSproofBuilderItem {

4683

1

                para_id: 1001.into(),

4684

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4685

1

                    parent_hash: Default::default(),

4686

1

                    number: 1,

4687

1

                    state_root: Default::default(),

4688

1

                    extrinsics_root: Default::default(),

4689

1

                    digest: sp_runtime::generic::Digest {

4690

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4691

1

},

4692

1

}),

4693

1

};

4694

1

4695

1

            sproof.items.push(s);

4696

1

            set_author_noting_inherent_data(sproof);

4697

1

4698

1

            run_block();

4699

1

4700

1

            // After this it should not be assigned anymore, since credits are not payable

4701

1

            run_to_session(3u32);

4702

1

            // Nobody should be assigned to para 1001

4703

1

            let assignment = CollatorAssignment::collator_container_chain();

4704

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4705

1

});

4706

1

4707

4708

#[test]

4709

1

fn test_ed_plus_block_credit_session_minus_1_purchase_fails() {

4710

1

    ExtBuilder::default()

4711

1

        .with_balances(vec![

4712

1

            // Alice gets 10k extra tokens for her mapping deposit

4713

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4714

1

            (AccountId::from(BOB), 100_000 * UNIT),

4715

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4716

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4717

1

])

4718

1

        .with_collators(vec![

4719

1

            (AccountId::from(ALICE), 210 * UNIT),

4720

1

            (AccountId::from(BOB), 100 * UNIT),

4721

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4722

1

            (AccountId::from(DAVE), 100 * UNIT),

4723

1

])

4724

1

        .build()

4725

1

        .execute_with(|| {

4726

1

            run_to_block(2);

4727

1

            // Assert current slot gets updated

4728

1

            assert_eq!(current_slot(), 1u64);

4729

1

            assert!(current_author() == AccountId::from(BOB));

4730

4731

            // Alice and Bob collate in our chain

4732

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4733

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4734

1

4735

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4736

4737

1

            assert_ok!(Registrar::register(

4738

1

                origin_of(ALICE.into()),

4739

1

                1001.into(),

4740

1

                empty_genesis_data()

4741

1

));

4742

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4743

1

            assert_ok!(Registrar::mark_valid_for_collating(

4744

1

                root_origin(),

4745

1

                1001.into()

4746

1

));

4747

            // Need to reset credits to 0 because now parachains are given free credits on register

4748

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4749

1

                root_origin(),

4750

1

                1001.into(),

4751

1

4752

1

));

4753

1

            let credits_1001 =

4754

1

                block_credits_to_required_balance(dancebox_runtime::Period::get(), 1001.into())

4755

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT

4756

1

                    - 1;

4757

1

4758

1

            // Fill the tank

4759

1

            assert_ok!(ServicesPayment::purchase_credits(

4760

1

                origin_of(ALICE.into()),

4761

1

                1001.into(),

4762

1

                credits_1001

4763

1

));

4764

4765

            // Assignment should happen after 2 sessions

4766

1

            run_to_session(1u32);

4767

1

            let assignment = CollatorAssignment::collator_container_chain();

4768

1

            assert!(assignment.container_chains.is_empty());

4769

1

            run_to_session(2u32);

4770

1

            // Charlie and Dave should not be assigned to para 1001

4771

1

            let assignment = CollatorAssignment::collator_container_chain();

4772

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4773

1

});

4774

1

4775

4776

#[test]

4777

1

fn test_reassignment_ed_plus_two_block_credit_session_purchase_works() {

4778

1

    ExtBuilder::default()

4779

1

        .with_balances(vec![

4780

1

            // Alice gets 10k extra tokens for her mapping deposit

4781

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4782

1

            (AccountId::from(BOB), 100_000 * UNIT),

4783

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4784

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4785

1

])

4786

1

        .with_collators(vec![

4787

1

            (AccountId::from(ALICE), 210 * UNIT),

4788

1

            (AccountId::from(BOB), 100 * UNIT),

4789

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4790

1

            (AccountId::from(DAVE), 100 * UNIT),

4791

1

])

4792

1

        .build()

4793

1

        .execute_with(|| {

4794

1

            run_to_block(2);

4795

1

            // Assert current slot gets updated

4796

1

            assert_eq!(current_slot(), 1u64);

4797

1

            assert!(current_author() == AccountId::from(BOB));

4798

4799

            // Alice and Bob collate in our chain

4800

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4801

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4802

1

4803

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4804

4805

1

            assert_ok!(Registrar::register(

4806

1

                origin_of(ALICE.into()),

4807

1

                1001.into(),

4808

1

                empty_genesis_data()

4809

1

));

4810

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4811

1

            assert_ok!(Registrar::mark_valid_for_collating(

4812

1

                root_origin(),

4813

1

                1001.into()

4814

1

));

4815

            // Need to reset credits to 0 because now parachains are given free credits on register

4816

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4817

1

                root_origin(),

4818

1

                1001.into(),

4819

1

4820

1

));

4821

            // On reassignment the blocks credits needed should be enough for the current session and the next one

4822

1

            let credits_1001 =

4823

1

                block_credits_to_required_balance(dancebox_runtime::Period::get() * 2, 1001.into())

4824

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT;

4825

1

4826

1

            // Fill the tank

4827

1

            assert_ok!(ServicesPayment::purchase_credits(

4828

1

                origin_of(ALICE.into()),

4829

1

                1001.into(),

4830

1

                credits_1001

4831

1

));

4832

4833

            // Assignment should happen after 2 sessions

4834

1

            run_to_session(1u32);

4835

1

            let assignment = CollatorAssignment::collator_container_chain();

4836

1

            assert!(assignment.container_chains.is_empty());

4837

4838

1

            run_to_session(2u32);

4839

1

            // Charlie and Dave should be assigned to para 1001

4840

1

            let assignment = CollatorAssignment::collator_container_chain();

4841

1

            assert_eq!(

4842

1

                assignment.container_chains[&1001u32.into()],

4843

1

                vec![CHARLIE.into(), DAVE.into()]

4844

1

);

4845

4846

            // Simulate block inclusion from container chain 1001

4847

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4848

1

            let slot: u64 = 5;

4849

1

            let s = ParaHeaderSproofBuilderItem {

4850

1

                para_id: 1001.into(),

4851

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4852

1

                    parent_hash: Default::default(),

4853

1

                    number: 1,

4854

1

                    state_root: Default::default(),

4855

1

                    extrinsics_root: Default::default(),

4856

1

                    digest: sp_runtime::generic::Digest {

4857

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4858

1

},

4859

1

}),

4860

1

};

4861

1

4862

1

            sproof.items.push(s);

4863

1

            set_author_noting_inherent_data(sproof);

4864

1

4865

1

            run_block();

4866

1

4867

1

            // Session 3 should still be assigned

4868

1

            run_to_session(3u32);

4869

1

            // Charlie and Dave should be assigned to para 1001

4870

1

            let assignment = CollatorAssignment::collator_container_chain();

4871

1

            assert_eq!(

4872

1

                assignment.container_chains[&1001u32.into()],

4873

1

                vec![CHARLIE.into(), DAVE.into()]

4874

1

);

4875

4876

            // After this it should not be assigned anymore, since credits are not payable

4877

1

            run_to_session(4u32);

4878

1

            // Nobody should be assigned to para 1001

4879

1

            let assignment = CollatorAssignment::collator_container_chain();

4880

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4881

1

});

4882

1

4883

4884

#[test]

4885

1

fn test_reassignment_ed_plus_two_block_credit_session_minus_1_purchase_fails() {

4886

1

    ExtBuilder::default()

4887

1

        .with_balances(vec![

4888

1

            // Alice gets 10k extra tokens for her mapping deposit

4889

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4890

1

            (AccountId::from(BOB), 100_000 * UNIT),

4891

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4892

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4893

1

])

4894

1

        .with_collators(vec![

4895

1

            (AccountId::from(ALICE), 210 * UNIT),

4896

1

            (AccountId::from(BOB), 100 * UNIT),

4897

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4898

1

            (AccountId::from(DAVE), 100 * UNIT),

4899

1

])

4900

1

        .build()

4901

1

        .execute_with(|| {

4902

1

            run_to_block(2);

4903

1

            // Assert current slot gets updated

4904

1

            assert_eq!(current_slot(), 1u64);

4905

1

            assert!(current_author() == AccountId::from(BOB));

4906

4907

            // Alice and Bob collate in our chain

4908

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

4909

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

4910

1

4911

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

4912

4913

1

            assert_ok!(Registrar::register(

4914

1

                origin_of(ALICE.into()),

4915

1

                1001.into(),

4916

1

                empty_genesis_data()

4917

1

));

4918

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

4919

1

            assert_ok!(Registrar::mark_valid_for_collating(

4920

1

                root_origin(),

4921

1

                1001.into()

4922

1

));

4923

            // Need to reset credits to 0 because now parachains are given free credits on register

4924

1

            assert_ok!(ServicesPayment::set_block_production_credits(

4925

1

                root_origin(),

4926

1

                1001.into(),

4927

1

4928

1

));

4929

1

            let credits_1001 =

4930

1

                block_credits_to_required_balance(dancebox_runtime::Period::get() * 2, 1001.into())

4931

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT

4932

1

                    - 1;

4933

1

4934

1

            // Fill the tank

4935

1

            assert_ok!(ServicesPayment::purchase_credits(

4936

1

                origin_of(ALICE.into()),

4937

1

                1001.into(),

4938

1

                credits_1001

4939

1

));

4940

4941

            // Assignment should happen after 2 sessions

4942

1

            run_to_session(1u32);

4943

1

            let assignment = CollatorAssignment::collator_container_chain();

4944

1

            assert!(assignment.container_chains.is_empty());

4945

4946

1

            run_to_session(2u32);

4947

1

            // Charlie and Dave should be assigned to para 1001

4948

1

            let assignment = CollatorAssignment::collator_container_chain();

4949

1

            assert_eq!(

4950

1

                assignment.container_chains[&1001u32.into()],

4951

1

                vec![CHARLIE.into(), DAVE.into()]

4952

1

);

4953

4954

            // Simulate block inclusion from container chain 1001

4955

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

4956

1

            let slot: u64 = 5;

4957

1

            let s = ParaHeaderSproofBuilderItem {

4958

1

                para_id: 1001.into(),

4959

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

4960

1

                    parent_hash: Default::default(),

4961

1

                    number: 1,

4962

1

                    state_root: Default::default(),

4963

1

                    extrinsics_root: Default::default(),

4964

1

                    digest: sp_runtime::generic::Digest {

4965

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

4966

1

},

4967

1

}),

4968

1

};

4969

1

4970

1

            sproof.items.push(s);

4971

1

            set_author_noting_inherent_data(sproof);

4972

1

4973

1

            run_block();

4974

1

4975

1

            // After this it should not be assigned anymore, since credits are not payable

4976

1

            run_to_session(3u32);

4977

1

            // Nobody should be assigned to para 1001

4978

1

            let assignment = CollatorAssignment::collator_container_chain();

4979

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

4980

1

});

4981

1

4982

4983

#[test]

4984

1

fn test_block_credits_with_purchase_can_be_combined() {

4985

1

    ExtBuilder::default()

4986

1

        .with_balances(vec![

4987

1

            // Alice gets 10k extra tokens for her mapping deposit

4988

1

            (AccountId::from(ALICE), 210_000 * UNIT),

4989

1

            (AccountId::from(BOB), 100_000 * UNIT),

4990

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

4991

1

            (AccountId::from(DAVE), 100_000 * UNIT),

4992

1

])

4993

1

        .with_collators(vec![

4994

1

            (AccountId::from(ALICE), 210 * UNIT),

4995

1

            (AccountId::from(BOB), 100 * UNIT),

4996

1

            (AccountId::from(CHARLIE), 100 * UNIT),

4997

1

            (AccountId::from(DAVE), 100 * UNIT),

4998

1

])

4999

1

        .build()

5000

1

        .execute_with(|| {

5001

1

            run_to_block(2);

5002

1

            // Assert current slot gets updated

5003

1

            assert_eq!(current_slot(), 1u64);

5004

1

            assert!(current_author() == AccountId::from(BOB));

5005

5006

            // Alice and Bob collate in our chain

5007

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5008

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5009

1

5010

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5011

5012

1

            assert_ok!(Registrar::register(

5013

1

                origin_of(ALICE.into()),

5014

1

                1001.into(),

5015

1

                empty_genesis_data()

5016

1

));

5017

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5018

1

            assert_ok!(Registrar::mark_valid_for_collating(

5019

1

                root_origin(),

5020

1

                1001.into()

5021

1

));

5022

            // Need to reset credits to 0 because now parachains are given free credits on register

5023

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5024

1

                root_origin(),

5025

1

                1001.into(),

5026

1

                dancebox_runtime::Period::get()

5027

1

));

5028

1

            let credits_1001 =

5029

1

                block_credits_to_required_balance(dancebox_runtime::Period::get(), 1001.into())

5030

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT;

5031

1

5032

1

            // Fill the tank

5033

1

            assert_ok!(ServicesPayment::purchase_credits(

5034

1

                origin_of(ALICE.into()),

5035

1

                1001.into(),

5036

1

                credits_1001

5037

1

));

5038

5039

            // Assignment should happen after 2 sessions

5040

1

            run_to_session(1u32);

5041

1

            let assignment = CollatorAssignment::collator_container_chain();

5042

1

            assert!(assignment.container_chains.is_empty());

5043

1

            run_to_session(2u32);

5044

1

            // Charlie and Dave should be assigned to para 1001

5045

1

            let assignment = CollatorAssignment::collator_container_chain();

5046

1

            assert_eq!(

5047

1

                assignment.container_chains[&1001u32.into()],

5048

1

                vec![CHARLIE.into(), DAVE.into()]

5049

1

);

5050

1

});

5051

1

5052

#[test]

5053

1

fn stream_payment_works() {

5054

1

    ExtBuilder::default()

5055

1

        .with_balances(vec![

5056

1

            (AccountId::from(ALICE), 100_000 * UNIT),

5057

1

            (AccountId::from(BOB), 100_000 * UNIT),

5058

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5059

1

])

5060

1

        .with_collators(vec![

5061

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5062

1

            (AccountId::from(DAVE), 100 * UNIT),

5063

1

])

5064

1

        .build()

5065

1

        .execute_with(|| {

5066

1

            use pallet_stream_payment::{ChangeKind, StreamConfig};

5067

1

5068

1

            assert_ok!(StreamPayment::open_stream(

5069

1

                origin_of(ALICE.into()),

5070

1

                BOB.into(),

5071

1

                StreamConfig {

5072

1

                    rate: 2 * UNIT,

5073

1

                    asset_id: StreamPaymentAssetId::Native,

5074

1

                    time_unit: TimeUnit::BlockNumber,

5075

1

},

5076

1

                1_000 * UNIT,

5077

1

));

5078

5079

1

            run_block();

5080

1

5081

1

            assert_ok!(StreamPayment::perform_payment(origin_of(CHARLIE.into()), 0));

5082

1

            assert_eq!(

5083

1

                Balances::free_balance(AccountId::from(BOB)),

5084

1

                100_000 * UNIT + 2 * UNIT

5085

1

);

5086

5087

1

            assert_ok!(StreamPayment::request_change(

5088

1

                origin_of(ALICE.into()),

5089

1

0,

5090

1

                ChangeKind::Suggestion,

5091

1

                StreamConfig {

5092

1

                    rate: 1 * UNIT,

5093

1

                    asset_id: StreamPaymentAssetId::Native,

5094

1

                    time_unit: TimeUnit::BlockNumber,

5095

1

},

5096

1

                None,

5097

1

));

5098

5099

1

            assert_ok!(StreamPayment::accept_requested_change(

5100

1

                origin_of(BOB.into()),

5101

1

0,

5102

1

                1, // nonce

5103

1

                None,

5104

1

));

5105

5106

1

            run_block();

5107

1

5108

1

            assert_ok!(StreamPayment::close_stream(origin_of(BOB.into()), 0));

5109

5110

1

            assert_eq!(

5111

1

                Balances::free_balance(AccountId::from(BOB)),

5112

1

                100_000 * UNIT + 3 * UNIT

5113

1

);

5114

1

            assert_eq!(

5115

1

                Balances::free_balance(AccountId::from(ALICE)),

5116

1

                100_000 * UNIT - 3 * UNIT

5117

1

);

5118

1

});

5119

1

5120

5121

#[test]

5122

1

fn test_ed_plus_collator_assignment_session_purchase_works() {

5123

1

    ExtBuilder::default()

5124

1

        .with_balances(vec![

5125

1

            // Alice gets 10k extra tokens for her mapping deposit

5126

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5127

1

            (AccountId::from(BOB), 100_000 * UNIT),

5128

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5129

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5130

1

])

5131

1

        .with_collators(vec![

5132

1

            (AccountId::from(ALICE), 210 * UNIT),

5133

1

            (AccountId::from(BOB), 100 * UNIT),

5134

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5135

1

            (AccountId::from(DAVE), 100 * UNIT),

5136

1

])

5137

1

        .build()

5138

1

        .execute_with(|| {

5139

1

            run_to_block(2);

5140

1

            // Assert current slot gets updated

5141

1

            assert_eq!(current_slot(), 1u64);

5142

1

            assert!(current_author() == AccountId::from(BOB));

5143

5144

            // Alice and Bob collate in our chain

5145

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5146

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5147

1

5148

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5149

5150

1

            assert_ok!(Registrar::register(

5151

1

                origin_of(ALICE.into()),

5152

1

                1001.into(),

5153

1

                empty_genesis_data()

5154

1

));

5155

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5156

1

            assert_ok!(Registrar::mark_valid_for_collating(

5157

1

                root_origin(),

5158

1

                1001.into()

5159

1

));

5160

            // Need to reset credits to 0 because now parachains are given free credits on register

5161

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5162

1

                root_origin(),

5163

1

                1001.into(),

5164

1

5165

1

));

5166

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5167

1

                + dancebox_runtime::EXISTENTIAL_DEPOSIT;

5168

1

5169

1

            // Fill the tank

5170

1

            assert_ok!(ServicesPayment::purchase_credits(

5171

1

                origin_of(ALICE.into()),

5172

1

                1001.into(),

5173

1

                credits_1001

5174

1

));

5175

5176

            // Assignment should happen after 2 sessions

5177

1

            run_to_session(1u32);

5178

1

            let assignment = CollatorAssignment::collator_container_chain();

5179

1

            assert!(assignment.container_chains.is_empty());

5180

1

            run_to_session(2u32);

5181

1

            // Charlie and Dave should be assigned to para 1001

5182

1

            let assignment = CollatorAssignment::collator_container_chain();

5183

1

            assert_eq!(

5184

1

                assignment.container_chains[&1001u32.into()],

5185

1

                vec![CHARLIE.into(), DAVE.into()]

5186

1

);

5187

5188

            // Simulate block inclusion from container chain 1001

5189

1

            let mut sproof: ParaHeaderSproofBuilder = ParaHeaderSproofBuilder::default();

5190

1

            let slot: u64 = 5;

5191

1

            let s = ParaHeaderSproofBuilderItem {

5192

1

                para_id: 1001.into(),

5193

1

                author_id: HeaderAs::NonEncoded(sp_runtime::generic::Header::<u32, BlakeTwo256> {

5194

1

                    parent_hash: Default::default(),

5195

1

                    number: 1,

5196

1

                    state_root: Default::default(),

5197

1

                    extrinsics_root: Default::default(),

5198

1

                    digest: sp_runtime::generic::Digest {

5199

1

                        logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())],

5200

1

},

5201

1

}),

5202

1

};

5203

1

            sproof.items.push(s);

5204

1

            set_author_noting_inherent_data(sproof);

5205

1

5206

1

            run_block();

5207

1

5208

1

            // After this it should not be assigned anymore, since credits are not payable

5209

1

            run_to_session(4u32);

5210

1

            // Nobody should be assigned to para 1001

5211

1

            let assignment = CollatorAssignment::collator_container_chain();

5212

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5213

1

});

5214

1

5215

5216

#[test]

5217

1

fn test_ed_plus_collator_assignment_credit_session_minus_1_purchase_fails() {

5218

1

    ExtBuilder::default()

5219

1

        .with_balances(vec![

5220

1

            // Alice gets 10k extra tokens for her mapping deposit

5221

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5222

1

            (AccountId::from(BOB), 100_000 * UNIT),

5223

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5224

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5225

1

])

5226

1

        .with_collators(vec![

5227

1

            (AccountId::from(ALICE), 210 * UNIT),

5228

1

            (AccountId::from(BOB), 100 * UNIT),

5229

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5230

1

            (AccountId::from(DAVE), 100 * UNIT),

5231

1

])

5232

1

        .build()

5233

1

        .execute_with(|| {

5234

1

            run_to_block(2);

5235

1

            // Assert current slot gets updated

5236

1

            assert_eq!(current_slot(), 1u64);

5237

1

            assert!(current_author() == AccountId::from(BOB));

5238

5239

            // Alice and Bob collate in our chain

5240

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5241

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5242

1

5243

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5244

5245

1

            assert_ok!(Registrar::register(

5246

1

                origin_of(ALICE.into()),

5247

1

                1001.into(),

5248

1

                empty_genesis_data()

5249

1

));

5250

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5251

1

            assert_ok!(Registrar::mark_valid_for_collating(

5252

1

                root_origin(),

5253

1

                1001.into()

5254

1

));

5255

            // Need to reset credits to 0 because now parachains are given free credits on register

5256

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5257

1

                root_origin(),

5258

1

                1001.into(),

5259

1

5260

1

));

5261

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5262

1

                + dancebox_runtime::EXISTENTIAL_DEPOSIT

5263

1

                - 1;

5264

1

5265

1

            // Fill the tank

5266

1

            assert_ok!(ServicesPayment::purchase_credits(

5267

1

                origin_of(ALICE.into()),

5268

1

                1001.into(),

5269

1

                credits_1001

5270

1

));

5271

5272

            // Assignment should happen after 2 sessions

5273

1

            run_to_session(1u32);

5274

1

            let assignment = CollatorAssignment::collator_container_chain();

5275

1

            assert!(assignment.container_chains.is_empty());

5276

1

            run_to_session(2u32);

5277

1

            // Charlie and Dave should not be assigned to para 1001

5278

1

            let assignment = CollatorAssignment::collator_container_chain();

5279

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5280

1

});

5281

1

5282

5283

#[test]

5284

1

fn test_collator_assignment_credits_with_purchase_can_be_combined() {

5285

1

    ExtBuilder::default()

5286

1

        .with_balances(vec![

5287

1

            // Alice gets 10k extra tokens for her mapping deposit

5288

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5289

1

            (AccountId::from(BOB), 100_000 * UNIT),

5290

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5291

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5292

1

])

5293

1

        .with_collators(vec![

5294

1

            (AccountId::from(ALICE), 210 * UNIT),

5295

1

            (AccountId::from(BOB), 100 * UNIT),

5296

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5297

1

            (AccountId::from(DAVE), 100 * UNIT),

5298

1

])

5299

1

        .build()

5300

1

        .execute_with(|| {

5301

1

            run_to_block(2);

5302

1

            // Assert current slot gets updated

5303

1

            assert_eq!(current_slot(), 1u64);

5304

1

            assert!(current_author() == AccountId::from(BOB));

5305

5306

            // Alice and Bob collate in our chain

5307

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5308

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5309

1

5310

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5311

5312

1

            assert_ok!(Registrar::register(

5313

1

                origin_of(ALICE.into()),

5314

1

                1001.into(),

5315

1

                empty_genesis_data()

5316

1

));

5317

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5318

1

            assert_ok!(Registrar::mark_valid_for_collating(

5319

1

                root_origin(),

5320

1

                1001.into()

5321

1

));

5322

5323

            // We assign one session to free credits

5324

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5325

1

                root_origin(),

5326

1

                1001.into(),

5327

1

5328

1

));

5329

            // We buy another session through the tank

5330

1

            let credits_1001 = collator_assignment_credits_to_required_balance(1, 1001.into())

5331

1

                + dancebox_runtime::EXISTENTIAL_DEPOSIT;

5332

1

5333

1

            // Fill the tank

5334

1

            assert_ok!(ServicesPayment::purchase_credits(

5335

1

                origin_of(ALICE.into()),

5336

1

                1001.into(),

5337

1

                credits_1001

5338

1

));

5339

5340

            // Assignment should happen after 2 sessions

5341

1

            run_to_session(1u32);

5342

1

            let assignment = CollatorAssignment::collator_container_chain();

5343

1

            assert!(assignment.container_chains.is_empty());

5344

1

            run_to_session(2u32);

5345

1

            // Charlie and Dave should be assigned to para 1001

5346

1

            let assignment = CollatorAssignment::collator_container_chain();

5347

1

            assert_eq!(

5348

1

                assignment.container_chains[&1001u32.into()],

5349

1

                vec![CHARLIE.into(), DAVE.into()]

5350

1

);

5351

1

});

5352

1

5353

5354

#[test]

5355

1

fn test_block_credits_and_collator_assignation_credits_through_tank() {

5356

1

    ExtBuilder::default()

5357

1

        .with_balances(vec![

5358

1

            // Alice gets 10k extra tokens for her mapping deposit

5359

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5360

1

            (AccountId::from(BOB), 100_000 * UNIT),

5361

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5362

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5363

1

])

5364

1

        .with_collators(vec![

5365

1

            (AccountId::from(ALICE), 210 * UNIT),

5366

1

            (AccountId::from(BOB), 100 * UNIT),

5367

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5368

1

            (AccountId::from(DAVE), 100 * UNIT),

5369

1

])

5370

1

        .build()

5371

1

        .execute_with(|| {

5372

1

            run_to_block(2);

5373

1

            // Assert current slot gets updated

5374

1

            assert_eq!(current_slot(), 1u64);

5375

1

            assert!(current_author() == AccountId::from(BOB));

5376

5377

            // Alice and Bob collate in our chain

5378

1

            let alice_id = get_aura_id_from_seed(&AccountId::from(ALICE).to_string());

5379

1

            let bob_id = get_aura_id_from_seed(&AccountId::from(BOB).to_string());

5380

1

5381

1

            assert_eq!(authorities(), vec![alice_id, bob_id]);

5382

5383

1

            assert_ok!(Registrar::register(

5384

1

                origin_of(ALICE.into()),

5385

1

                1001.into(),

5386

1

                empty_genesis_data()

5387

1

));

5388

1

            set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5389

1

            assert_ok!(Registrar::mark_valid_for_collating(

5390

1

                root_origin(),

5391

1

                1001.into()

5392

1

));

5393

5394

            // We make all free credits 0

5395

1

            assert_ok!(ServicesPayment::set_collator_assignment_credits(

5396

1

                root_origin(),

5397

1

                1001.into(),

5398

1

5399

1

));

5400

1

            assert_ok!(ServicesPayment::set_block_production_credits(

5401

1

                root_origin(),

5402

1

                1001.into(),

5403

1

5404

1

));

5405

5406

            // We buy 2 sessions through tank

5407

1

            let collator_assignation_credits =

5408

1

                collator_assignment_credits_to_required_balance(2, 1001.into());

5409

1

            let block_production_credits =

5410

1

                block_credits_to_required_balance(dancebox_runtime::Period::get() * 2, 1001.into());

5411

1

5412

1

            // Fill the tank

5413

1

            assert_ok!(ServicesPayment::purchase_credits(

5414

1

                origin_of(ALICE.into()),

5415

1

                1001.into(),

5416

1

                collator_assignation_credits

5417

1

                    + block_production_credits

5418

1

                    + dancebox_runtime::EXISTENTIAL_DEPOSIT

5419

1

));

5420

5421

            // Assignment should happen after 2 sessions

5422

1

            run_to_session(1u32);

5423

1

            let assignment = CollatorAssignment::collator_container_chain();

5424

1

            assert!(assignment.container_chains.is_empty());

5425

1

            run_to_session(2u32);

5426

1

            // Charlie and Dave should be assigned to para 1001

5427

1

            let assignment = CollatorAssignment::collator_container_chain();

5428

1

            assert_eq!(

5429

1

                assignment.container_chains[&1001u32.into()],

5430

1

                vec![CHARLIE.into(), DAVE.into()]

5431

1

);

5432

5433

            // After this it should not be assigned anymore, since credits are not payable

5434

1

            run_to_session(4u32);

5435

1

            // Nobody should be assigned to para 1001

5436

1

            let assignment = CollatorAssignment::collator_container_chain();

5437

1

            assert_eq!(assignment.container_chains.get(&1001u32.into()), None,);

5438

1

});

5439

1

5440

5441

#[test]

5442

1

fn test_migration_services_collator_assignment_payment() {

5443

1

    ExtBuilder::default().build().execute_with(|| {

5444

1

        // Register a new parachain with no credits

5445

1

        assert_ok!(Registrar::register(

5446

1

            origin_of(ALICE.into()),

5447

1

            1001.into(),

5448

1

            empty_genesis_data()

5449

1

));

5450

1

        set_dummy_boot_node(origin_of(ALICE.into()), 1001.into());

5451

1

        assert_ok!(Registrar::mark_valid_for_collating(

5452

1

            root_origin(),

5453

1

            1001.into()

5454

1

));

5455

        // Register another parachain with no credits, do not mark this as valid for collation

5456

1

        assert_ok!(Registrar::register(

5457

1

            origin_of(ALICE.into()),

5458

1

            1002.into(),

5459

1

            empty_genesis_data()

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!(

5498

1

            credits_1001,

5499

1

            dancebox_runtime::FreeCollatorAssignmentCredits::get()

5500

1

);

5501

1

        let credits_1002 =

5502

1

            pallet_services_payment::CollatorAssignmentCredits::<Runtime>::get(ParaId::from(1002))

5503

1

                .unwrap_or_default();

5504

1

        assert_eq!(

5505

1

            credits_1002,

5506

1

            dancebox_runtime::FreeCollatorAssignmentCredits::get()

5507

1

);

5508

1

});

5509

1

5510

5511

#[test]

5512

1

fn test_migration_foreign_asset_creator() {

5513

1

    ExtBuilder::default().build().execute_with(|| {

5514

1

        // Sample pairs of asset id with v3 location

5515

1

        let (asset_id1, location_1) = (

5516

1

            <Runtime as pallet_assets::Config<ForeignAssetsInstance>>::AssetId::from(13u16),

5517

1

            V3MultiLocation::new(

5518

1

1,

5519

1

                V3Junctions::X2(

5520

1

                    V3Junction::PalletInstance(1),

5521

1

                    V3Junction::AccountIndex64 {

5522

1

                        network: Some(V3NetworkId::BitcoinCore),

5523

1

                        index: 5,

5524

1

},

5525

1

),

5526

1

),

5527

1

);

5528

1

5529

1

        let (asset_id2, location_2) = (

5530

1

            <Runtime as pallet_assets::Config<ForeignAssetsInstance>>::AssetId::from(14u16),

5531

1

            V3MultiLocation::new(

5532

1

1,

5533

1

                V3Junctions::X2(

5534

1

                    V3Junction::PalletInstance(2),

5535

1

                    V3Junction::AccountIndex64 {

5536

1

                        network: Some(V3NetworkId::Kusama),

5537

1

                        index: 10,

5538

1

},

5539

1

),

5540

1

),

5541

1

);

5542

1

5543

1

        put_storage_value(

5544

1

            AssetIdToForeignAsset::<Runtime>::pallet_prefix(),

5545

1

            AssetIdToForeignAsset::<Runtime>::storage_prefix(),

5546

1

            &asset_id1.blake2_128_concat(),

5547

1

            location_1,

5548

1

);

5549

1

        put_storage_value(

5550

1

            AssetIdToForeignAsset::<Runtime>::pallet_prefix(),

5551

1

            AssetIdToForeignAsset::<Runtime>::storage_prefix(),

5552

1

            &asset_id2.blake2_128_concat(),

5553

1

            location_2,

5554

1

);

5555

1

5556

1

        put_storage_value(

5557

1

            ForeignAssetToAssetId::<Runtime>::pallet_prefix(),

5558

1

            ForeignAssetToAssetId::<Runtime>::storage_prefix(),

5559

1

            &location_1.blake2_128_concat(),

5560

1

            asset_id1,

5561

1

);

5562

1

        put_storage_value(

5563

1

            ForeignAssetToAssetId::<Runtime>::pallet_prefix(),

5564

1

            ForeignAssetToAssetId::<Runtime>::storage_prefix(),

5565

1

            &location_2.blake2_128_concat(),

5566

1

            asset_id2,

5567

1

);

5568

1

5569

1

        // Let's run the migration now

5570

1

        let foreign_asset_creator_migration: ForeignAssetCreatorMigration<Runtime> =

5571

1

            ForeignAssetCreatorMigration(PhantomData);

5572

1

        let weight_consumed = foreign_asset_creator_migration.migrate(Default::default());

5573

1

        assert_eq!(

5574

1

            weight_consumed,

5575

1

            <Runtime as frame_system::Config>::DbWeight::get().reads_writes(1 * 4, 2 * 4)

5576

1

);

5577

5578

        // Let's check if everything is migrated properly

5579

1

        assert_eq!(

5580

1

            AssetIdToForeignAsset::<Runtime>::get(asset_id1),

5581

1

            Some(Location::try_from(location_1).unwrap())

5582

1

);

5583

1

        assert_eq!(

5584

1

            AssetIdToForeignAsset::<Runtime>::get(asset_id2),

5585

1

            Some(Location::try_from(location_2).unwrap())

5586

1

);

5587

5588

1

        assert_eq!(

5589

1

            ForeignAssetToAssetId::<Runtime>::get(Location::try_from(location_1).unwrap()),

5590

1

            Some(asset_id1)

5591

1

);

5592

1

        assert_eq!(

5593

1

            ForeignAssetToAssetId::<Runtime>::get(Location::try_from(location_2).unwrap()),

5594

1

            Some(asset_id2)

5595

1

);

5596

1

});

5597

1

5598

5599

#[test]

5600

1

fn test_max_collators_uses_pending_value() {

5601

1

    // Start with max_collators = 100, and collators_per_container = 2

5602

1

    // Set max_collators = 2, and collators_per_container = 3

5603

1

    // It should be impossible to have more than 2 collators per container at any point in time

5604

1

    ExtBuilder::default()

5605

1

        .with_balances(vec![

5606

1

            // Alice gets 10k extra tokens for her mapping deposit

5607

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5608

1

            (AccountId::from(BOB), 100_000 * UNIT),

5609

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5610

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5611

1

])

5612

1

        .with_collators(vec![

5613

1

            (AccountId::from(ALICE), 210 * UNIT),

5614

1

            (AccountId::from(BOB), 100 * UNIT),

5615

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5616

1

            (AccountId::from(DAVE), 100 * UNIT),

5617

1

])

5618

1

        .with_para_ids(vec![(1001, empty_genesis_data(), u32::MAX, u32::MAX).into()])

5619

1

        .with_config(pallet_configuration::HostConfiguration {

5620

1

            max_collators: 100,

5621

1

            min_orchestrator_collators: 1,

5622

1

            max_orchestrator_collators: 1,

5623

1

            collators_per_container: 2,

5624

1

            full_rotation_period: 24,

5625

1

            ..Default::default()

5626

1

})

5627

1

        .build()

5628

1

        .execute_with(|| {

5629

1

            run_to_block(2);

5630

1

5631

1

            // Initial assignment: 1 collator in orchestrator chain and 2 collators in container 1001

5632

1

            let assignment = CollatorAssignment::collator_container_chain();

5633

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 2);

5634

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5635

5636

1

            assert_ok!(Configuration::set_max_collators(root_origin(), 2));

5637

1

            assert_ok!(Configuration::set_collators_per_container(root_origin(), 3));

5638

5639

            // Check invariant for all intermediate assignments. We set collators_per_container = 3

5640

            // but we also set max_collators = 2, so no collators will be assigned to container

5641

            // chains after the change is applied.

5642

5

            for session in 1..=4 {

5643

4

                run_to_session(session);

5644

4

5645

4

                let assignment = CollatorAssignment::collator_container_chain();

5646

4

                assert!(

5647

4

                    assignment.container_chains[&1001u32.into()].len() <= 2,

5648

                    "session {}: {} collators assigned to container chain 1001",

5649

                    session,

5650

                    assignment.container_chains[&1001u32.into()].len()

5651

);

5652

5653

5654

            // Final assignment: because max_collators = 2, there are only 2 collators, one in

5655

            // orchestrator chain, and the other one idle

5656

1

            let assignment = CollatorAssignment::collator_container_chain();

5657

1

            assert_eq!(assignment.container_chains[&1001u32.into()].len(), 0);

5658

1

            assert_eq!(assignment.orchestrator_chain.len(), 1);

5659

1

});

5660

1

5661

5662

#[test]

5663

1

fn test_slow_adjusting_multiplier_changes_in_response_to_consumed_weight() {

5664

1

    ExtBuilder::default()

5665

1

        .with_collators(vec![

5666

1

            (AccountId::from(ALICE), 210 * UNIT),

5667

1

            (AccountId::from(BOB), 100 * UNIT),

5668

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5669

1

            (AccountId::from(DAVE), 100 * UNIT),

5670

1

])

5671

1

        .build()

5672

1

        .execute_with(|| {

5673

1

            end_block();

5674

1

            // If the block is full, the multiplier increases

5675

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5676

1

            start_block();

5677

1

            let max_block_weights = dancebox_runtime::RuntimeBlockWeights::get();

5678

1

            frame_support::storage::unhashed::put(

5679

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5680

3

                &ConsumedWeight::new(|class| {

5681

3

                    max_block_weights

5682

3

                        .get(class)

5683

3

                        .max_total

5684

3

                        .unwrap_or(Weight::MAX)

5685

3

}),

5686

1

);

5687

1

            end_block();

5688

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5689

1

            assert!(current_multiplier > before_multiplier);

5690

5691

            // If the block is empty, the multiplier decreases

5692

1

            let before_multiplier = TransactionPayment::next_fee_multiplier();

5693

1

            start_block();

5694

1

            frame_support::storage::unhashed::put(

5695

1

                &frame_support::storage::storage_prefix(b"System", b"BlockWeight"),

5696

3

                &ConsumedWeight::new(|_class| Weight::zero()),

5697

1

);

5698

1

            end_block();

5699

1

            let current_multiplier = TransactionPayment::next_fee_multiplier();

5700

1

            assert!(current_multiplier < before_multiplier);

5701

1

});

5702

1

5703

5704

#[test]

5705

1

fn test_collator_assignment_tip_priority_on_congestion() {

5706

1

    ExtBuilder::default()

5707

1

        .with_balances(vec![

5708

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5709

1

            (AccountId::from(BOB), 100_000 * UNIT),

5710

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5711

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5712

1

])

5713

1

        .with_collators(vec![

5714

1

            (AccountId::from(ALICE), 210 * UNIT),

5715

1

            (AccountId::from(BOB), 100 * UNIT),

5716

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5717

1

            (AccountId::from(DAVE), 100 * UNIT),

5718

1

])

5719

1

        .with_para_ids(vec![

5720

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5721

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5722

1

            (1003, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5723

1

])

5724

1

        .build()

5725

1

        .execute_with(|| {

5726

1

            let para_id = 1003u32;

5727

1

            let tank_funds = 100 * UNIT;

5728

1

            let max_tip = 1 * UNIT;

5729

1

5730

1

            assert_eq!(

5731

1

                CollatorAssignment::collator_container_chain().container_chains[&1003u32.into()]

5732

1

                    .len(),

5733

1

5734

1

);

5735

5736

            // Send funds to tank

5737

1

            assert_ok!(ServicesPayment::purchase_credits(

5738

1

                origin_of(ALICE.into()),

5739

1

                para_id.into(),

5740

1

                tank_funds,

5741

1

));

5742

5743

            // Set tip for 1003

5744

1

            assert_ok!(ServicesPayment::set_max_tip(

5745

1

                root_origin(),

5746

1

                para_id.into(),

5747

1

                Some(max_tip),

5748

1

));

5749

5750

1

            run_to_session(2);

5751

1

            assert_eq!(

5752

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5753

1

                    .len(),

5754

1

2,

5755

1

);

5756

1

});

5757

1

5758

5759

#[test]

5760

1

fn test_collator_assignment_tip_charged_on_congestion() {

5761

1

    ExtBuilder::default()

5762

1

        .with_balances(vec![

5763

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5764

1

            (AccountId::from(BOB), 100_000 * UNIT),

5765

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5766

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5767

1

])

5768

1

        .with_collators(vec![

5769

1

            (AccountId::from(ALICE), 210 * UNIT),

5770

1

            (AccountId::from(BOB), 100 * UNIT),

5771

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5772

1

            (AccountId::from(DAVE), 100 * UNIT),

5773

1

])

5774

1

        .with_para_ids(vec![

5775

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5776

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5777

1

            (1003, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5778

1

])

5779

1

        .build()

5780

1

        .execute_with(|| {

5781

1

            let tank_funds = 100 * UNIT;

5782

1

            let max_tip = 1 * UNIT;

5783

1

            let para_id = 1003u32;

5784

1

5785

1

            // Send funds to tank

5786

1

            assert_ok!(ServicesPayment::purchase_credits(

5787

1

                origin_of(ALICE.into()),

5788

1

                para_id.into(),

5789

1

                tank_funds,

5790

1

));

5791

5792

            // Set tip for para_id

5793

1

            assert_ok!(ServicesPayment::set_max_tip(

5794

1

                root_origin(),

5795

1

                para_id.into(),

5796

1

                Some(max_tip),

5797

1

));

5798

5799

1

            run_to_session(1);

5800

1

            assert_eq!(

5801

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id.into())),

5802

1

                tank_funds - max_tip,

5803

1

);

5804

1

});

5805

1

5806

5807

#[test]

5808

1

fn test_collator_assignment_tip_not_assigned_on_insufficient_balance() {

5809

1

    ExtBuilder::default()

5810

1

        .with_balances(vec![

5811

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5812

1

            (AccountId::from(BOB), 100_000 * UNIT),

5813

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5814

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5815

1

])

5816

1

        .with_collators(vec![

5817

1

            (AccountId::from(ALICE), 210 * UNIT),

5818

1

            (AccountId::from(BOB), 100 * UNIT),

5819

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5820

1

            (AccountId::from(DAVE), 100 * UNIT),

5821

1

])

5822

1

        .with_para_ids(vec![

5823

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5824

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5825

1

            (1003, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5826

1

])

5827

1

        .build()

5828

1

        .execute_with(|| {

5829

1

            let tank_funds = 1 * UNIT;

5830

1

            let max_tip = 1 * UNIT;

5831

1

            let para_id = 1003u32;

5832

1

5833

1

            // Send insufficient funds to tank for tip for 2 sessions

5834

1

            assert_ok!(ServicesPayment::purchase_credits(

5835

1

                origin_of(ALICE.into()),

5836

1

                para_id.into(),

5837

1

                tank_funds,

5838

1

));

5839

5840

            // Set tip for para_id

5841

1

            assert_ok!(ServicesPayment::set_max_tip(

5842

1

                root_origin(),

5843

1

                para_id.into(),

5844

1

                Some(max_tip),

5845

1

));

5846

5847

1

            run_to_session(1);

5848

1

            assert_eq!(

5849

1

                CollatorAssignment::collator_container_chain().container_chains[&para_id.into()]

5850

1

                    .len(),

5851

1

5852

1

);

5853

1

});

5854

1

5855

5856

#[test]

5857

1

fn test_collator_assignment_tip_only_charge_willing_paras() {

5858

1

    ExtBuilder::default()

5859

1

        .with_balances(vec![

5860

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5861

1

            (AccountId::from(BOB), 100_000 * UNIT),

5862

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5863

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5864

1

            (AccountId::from(EVE), 100_000 * UNIT),

5865

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5866

1

])

5867

1

        .with_collators(vec![

5868

1

            (AccountId::from(ALICE), 210 * UNIT),

5869

1

            (AccountId::from(BOB), 100 * UNIT),

5870

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5871

1

            (AccountId::from(DAVE), 100 * UNIT),

5872

1

            (AccountId::from(EVE), 100 * UNIT),

5873

1

            (AccountId::from(FERDIE), 100 * UNIT),

5874

1

])

5875

1

        .with_para_ids(vec![

5876

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5877

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5878

1

            (1003, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5879

1

])

5880

1

        .build()

5881

1

        .execute_with(|| {

5882

1

            let tank_funds = 100 * UNIT;

5883

1

            let max_tip = 1 * UNIT;

5884

1

            let para_id_with_tip = 1003u32;

5885

1

            let para_id_without_tip = 1001u32;

5886

1

5887

1

            // Send funds to tank to both paras

5888

1

            assert_ok!(ServicesPayment::purchase_credits(

5889

1

                origin_of(ALICE.into()),

5890

1

                para_id_with_tip.into(),

5891

1

                tank_funds,

5892

1

));

5893

1

            assert_ok!(ServicesPayment::purchase_credits(

5894

1

                origin_of(ALICE.into()),

5895

1

                para_id_without_tip.into(),

5896

1

                tank_funds,

5897

1

));

5898

5899

            // Only set tip for 1003

5900

1

            assert_ok!(ServicesPayment::set_max_tip(

5901

1

                root_origin(),

5902

1

                para_id_with_tip.into(),

5903

1

                Some(max_tip),

5904

1

));

5905

5906

1

            run_to_session(2);

5907

1

5908

1

            let assignment = CollatorAssignment::collator_container_chain().container_chains;

5909

1

5910

1

            // 2 out of the 3 paras should have collators assigned, with one paying tip to get

5911

1

            // prioritized, and the other selected at random that should not be charged any tips

5912

1

            assert_eq!(assignment[&para_id_with_tip.into()].len(), 2);

5913

1

            assert_eq!(

5914

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_with_tip.into())),

5915

1

                tank_funds - max_tip * 2,

5916

1

);

5917

5918

1

            assert_eq!(assignment[&para_id_without_tip.into()].len(), 2);

5919

1

            assert_eq!(

5920

1

                Balances::usable_balance(ServicesPayment::parachain_tank(

5921

1

                    para_id_without_tip.into()

5922

1

)),

5923

1

                tank_funds,

5924

1

);

5925

1

});

5926

1

5927

5928

#[test]

5929

1

fn test_collator_assignment_tip_withdraw_min_tip() {

5930

1

    ExtBuilder::default()

5931

1

        .with_balances(vec![

5932

1

            (AccountId::from(ALICE), 210_000 * UNIT),

5933

1

            (AccountId::from(BOB), 100_000 * UNIT),

5934

1

            (AccountId::from(CHARLIE), 100_000 * UNIT),

5935

1

            (AccountId::from(DAVE), 100_000 * UNIT),

5936

1

            (AccountId::from(EVE), 100_000 * UNIT),

5937

1

            (AccountId::from(FERDIE), 100_000 * UNIT),

5938

1

])

5939

1

        .with_collators(vec![

5940

1

            (AccountId::from(ALICE), 210 * UNIT),

5941

1

            (AccountId::from(BOB), 100 * UNIT),

5942

1

            (AccountId::from(CHARLIE), 100 * UNIT),

5943

1

            (AccountId::from(DAVE), 100 * UNIT),

5944

1

            (AccountId::from(EVE), 100 * UNIT),

5945

1

            (AccountId::from(FERDIE), 100 * UNIT),

5946

1

])

5947

1

        .with_para_ids(vec![

5948

1

            (1001, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5949

1

            (1002, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5950

1

            (1003, empty_genesis_data(), u32::MAX, u32::MAX).into(),

5951

1

])

5952

1

        .build()

5953

1

        .execute_with(|| {

5954

1

            let tank_funds = 100 * UNIT;

5955

1

            let max_tip_1003 = 3 * UNIT;

5956

1

            let max_tip_1002 = 2 * UNIT;

5957

1

            let para_id_1003 = 1003u32;

5958

1

            let para_id_1002 = 1002u32;

5959

1

5960

1

            // Send funds to tank to both paras

5961

1

            assert_ok!(ServicesPayment::purchase_credits(

5962

1

                origin_of(ALICE.into()),

5963

1

                para_id_1003.into(),

5964

1

                tank_funds,

5965

1

));

5966

1

            assert_ok!(ServicesPayment::purchase_credits(

5967

1

                origin_of(ALICE.into()),

5968

1

                para_id_1002.into(),

5969

1

                tank_funds,

5970

1

));

5971

5972

            // Set tips

5973

1

            assert_ok!(ServicesPayment::set_max_tip(

5974

1

                root_origin(),

5975

1

                para_id_1003.into(),

5976

1

                Some(max_tip_1003),

5977

1

));

5978

1

            assert_ok!(ServicesPayment::set_max_tip(

5979

1

                root_origin(),

5980

1

                para_id_1002.into(),

5981

1

                Some(max_tip_1002),

5982

1

));

5983

5984

1

            run_to_session(2);

5985

1

5986

1

            assert_eq!(

5987

1

                CollatorAssignment::collator_container_chain().container_chains

5988

1

                    [&para_id_1003.into()]

5989

1

                    .len(),

5990

1

5991

1

);

5992

1

            assert_eq!(

5993

1

                CollatorAssignment::collator_container_chain().container_chains

5994

1

                    [&para_id_1002.into()]

5995

1

                    .len(),

5996

1

5997

1

);

5998

5999

            // Should have withdrawn the lowest tip from both paras

6000

1

            assert_eq!(

6001

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1003.into())),

6002

1

                tank_funds - max_tip_1002 * 2,

6003

1

);

6004

6005

1

            assert_eq!(

6006

1

                Balances::usable_balance(ServicesPayment::parachain_tank(para_id_1002.into())),

6007

1

                tank_funds - max_tip_1002 * 2,

6008

1

);

6009

1

});

6010

1

6011

6012

#[test]

6013

1

fn test_migration_data_preservers_assignments() {

6014

1

    ExtBuilder::default().build().execute_with(|| {

6015

1

        use {

6016

1

            dancebox_runtime::{MaxAssignmentsPerParaId, MaxNodeUrlLen},

6017

1

            frame_support::{

6018

1

                migration::{have_storage_value, put_storage_value},

6019

1

                Blake2_128Concat, StorageHasher,

6020

1

},

6021

1

            pallet_data_preservers::{ParaIdsFilter, Profile, ProfileMode, RegisteredProfile},

6022

1

            sp_runtime::BoundedBTreeSet,

6023

1

            sp_std::collections::btree_set::BTreeSet,

6024

1

            tanssi_runtime_common::migrations::DataPreserversAssignmentsMigration,

6025

1

};

6026

1

6027

1

        macro_rules! bset {

6028

1

            ( $($value:expr),* $(,)? ) => {

6029

1

6030

1

                    let mut set = BoundedBTreeSet::new();

6031

1

$(

6032

1

                        set.try_insert($value).expect("max bound reached");

6033

1

)*

6034

1

set

6035

1

6036

1

6037

1

6038

1

6039

1

        macro_rules! set {

6040

1

            ( $($value:expr),* $(,)? ) => {

6041

1

6042

1

                    let mut set = BTreeSet::new();

6043

1

$(

6044

1

                        set.insert($value);

6045

1

)*

6046

1

set

6047

1

6048

1

6049

1

6050

1

6051

1

        let account = AccountId::from([0u8; 32]);

6052

1

        let free_request = dancebox_runtime::PreserversAssignementPaymentRequest::Free;

6053

1

        let free_witness = dancebox_runtime::PreserversAssignementPaymentWitness::Free;

6054

1

6055

1

        let pallet_prefix: &[u8] = b"DataPreservers";

6056

1

        let storage_item_prefix: &[u8] = b"BootNodes";

6057

1

6058

1

        // Register 2 parachains

6059

1

        assert_ok!(Registrar::register(

6060

1

            origin_of(ALICE.into()),

6061

1

            1001.into(),

6062

1

            empty_genesis_data()

6063

1

));

6064

1

        assert_ok!(Registrar::register(

6065

1

            origin_of(BOB.into()),

6066

1

            1002.into(),

6067

1

            empty_genesis_data()

6068

1

));

6069

6070

        // Set bootnodes in old storage

6071

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

6072

1

            b"alpha".to_vec().try_into().unwrap(),

6073

1

            b"beta".to_vec().try_into().unwrap(),

6074

1

6075

1

        .try_into()

6076

1

        .unwrap();

6077

1

        put_storage_value(

6078

1

            pallet_prefix,

6079

1

            storage_item_prefix,

6080

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode()),

6081

1

            bootnodes,

6082

1

);

6083

1

6084

1

        let bootnodes: BoundedVec<BoundedVec<u8, MaxNodeUrlLen>, MaxAssignmentsPerParaId> = vec![

6085

1

            b"delta".to_vec().try_into().unwrap(),

6086

1

            b"gamma".to_vec().try_into().unwrap(),

6087

1

6088

1

        .try_into()

6089

1

        .unwrap();

6090

1

        put_storage_value(

6091

1

            pallet_prefix,

6092

1

            storage_item_prefix,

6093

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode()),

6094

1

            bootnodes,

6095

1

);

6096

1

6097

1

        // Apply migration

6098

1

        let migration = DataPreserversAssignmentsMigration::<Runtime>(Default::default());

6099

1

        migration.migrate(Default::default());

6100

1

6101

1

        // Check old storage is empty

6102

1

        assert!(!have_storage_value(

6103

1

            pallet_prefix,

6104

1

            storage_item_prefix,

6105

1

            &Blake2_128Concat::hash(&ParaId::from(1001).encode())

6106

1

));

6107

1

        assert!(!have_storage_value(

6108

1

            pallet_prefix,

6109

1

            storage_item_prefix,

6110

1

            &Blake2_128Concat::hash(&ParaId::from(1002).encode())

6111

1

));

6112

6113

        // Check new storage

6114

1

        assert_eq!(

6115

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1001)).into_inner(),

6116

1

            set![0, 1]

6117

1

);

6118

1

        assert_eq!(

6119

1

            pallet_data_preservers::Assignments::<Runtime>::get(ParaId::from(1002)).into_inner(),

6120

1

            set![2, 3]

6121

1

);

6122

1

        assert_eq!(pallet_data_preservers::NextProfileId::<Runtime>::get(), 4);

6123

1

        assert_eq!(

6124

1

            pallet_data_preservers::Profiles::<Runtime>::get(0),

6125

1

            Some(RegisteredProfile {

6126

1

                account: account.clone(),

6127

1

                deposit: 0,

6128

1

                assignment: Some((1001.into(), free_witness)),

6129

1

                profile: Profile {

6130

1

                    url: b"alpha".to_vec().try_into().unwrap(),

6131

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

6132

1

                    mode: ProfileMode::Bootnode,

6133

1

                    assignment_request: free_request,

6134

1

6135

1

})

6136

1

);

6137

1

        assert_eq!(

6138

1

            pallet_data_preservers::Profiles::<Runtime>::get(1),

6139

1

            Some(RegisteredProfile {

6140

1

                account: account.clone(),

6141

1

                deposit: 0,

6142

1

                assignment: Some((1001.into(), free_witness)),

6143

1

                profile: Profile {

6144

1

                    url: b"beta".to_vec().try_into().unwrap(),

6145

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1001.into()]),

6146

1

                    mode: ProfileMode::Bootnode,

6147

1

                    assignment_request: free_request,

6148

1

6149

1

})

6150

1

);

6151

1

        assert_eq!(

6152

1

            pallet_data_preservers::Profiles::<Runtime>::get(2),

6153

1

            Some(RegisteredProfile {

6154

1

                account: account.clone(),

6155

1

                deposit: 0,

6156

1

                assignment: Some((1002.into(), free_witness)),

6157

1

                profile: Profile {

6158

1

                    url: b"delta".to_vec().try_into().unwrap(),

6159

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

6160

1

                    mode: ProfileMode::Bootnode,

6161

1

                    assignment_request: free_request,

6162

1

6163

1

})

6164

1

);

6165

1

        assert_eq!(

6166

1

            pallet_data_preservers::Profiles::<Runtime>::get(3),

6167

1

            Some(RegisteredProfile {

6168

1

                account: account.clone(),

6169

1

                deposit: 0,

6170

1

                assignment: Some((1002.into(), free_witness)),

6171

1

                profile: Profile {

6172

1

                    url: b"gamma".to_vec().try_into().unwrap(),

6173

1

                    para_ids: ParaIdsFilter::Whitelist(bset![1002.into()]),

6174

1

                    mode: ProfileMode::Bootnode,

6175

1

                    assignment_request: free_request,

6176

1

6177

1

})

6178

1

);

6179

1

})

6180

1

6181

6182

#[test]

6183

1

fn test_migration_registrar_reserves_to_hold() {

6184

1

    ExtBuilder::default()

6185

1

        .with_balances(vec![(AccountId::from(DAVE), 100_000 * UNIT)])

6186

1

        .build()

6187

1

        .execute_with(|| {

6188

1

            use {

6189

1

                frame_support::traits::{fungible::InspectHold, ReservableCurrency},

6190

1

                pallet_registrar::DepositInfo,

6191

1

                tanssi_runtime_common::migrations::RegistrarReserveToHoldMigration,

6192

1

};

6193

1

6194

1

            let deposit: Balance = 100 * UNIT;

6195

1

            let account: AccountId = DAVE.into();

6196

1

6197

1

            assert_ok!(Balances::reserve(&account, deposit));

6198

6199

1

            pallet_registrar::RegistrarDeposit::<Runtime>::insert(

6200

1

                ParaId::from(1001),

6201

1

                DepositInfo {

6202

1

                    creator: account.clone(),

6203

1

                    deposit: deposit,

6204

1

},

6205

1

);

6206

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

6207

            // Apply migration

6208

1

            let migration = RegistrarReserveToHoldMigration::<Runtime>(Default::default());

6209

1

            migration.migrate(Default::default());

6210

1

6211

1

            // Holds also count as reserved balance, so the total reserved amount

6212

1

            // shouldn't change after the migration

6213

1

            assert_eq!(Balances::reserved_balance(&account), deposit.clone(),);

6214

6215

1

            assert_eq!(

6216

1

                Balances::balance_on_hold(

6217

1

                    &pallet_registrar::HoldReason::RegistrarDeposit.into(),

6218

1

                    &account

6219

1

),

6220

1

                deposit

6221

1

);

6222

1

})

6223

1