Grcov report - tests.rs

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

// Moonbeam 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

// Moonbeam 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 Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

16

17

//! # Staking Pallet Unit Tests

18

//! The unit tests are organized by the call they test. The order matches the order

19

//! of the calls in the `lib.rs`.

20

//! 1. Root

21

//! 2. Monetary Governance

22

//! 3. Public (Collator, Nominator)

23

//! 4. Miscellaneous Property-Based Tests

24

25

use crate::auto_compound::{AutoCompoundConfig, AutoCompoundDelegations};

26

use crate::delegation_requests::{CancelledScheduledRequest, DelegationAction, ScheduledRequest};

27

use crate::migrations::MigrateDelegationScheduledRequestsToDoubleMap;

28

use crate::mock::{

29

	inflation_configs, query_freeze_amount, roll_blocks, roll_to, roll_to_round_begin,

30

	roll_to_round_end, set_author, set_block_author, AccountId, Balances, BlockNumber, ExtBuilder,

31

	ParachainStaking, RuntimeEvent, RuntimeOrigin, Test, POINTS_PER_BLOCK, POINTS_PER_ROUND,

32

};

33

use crate::RoundIndex;

34

use crate::{

35

	assert_events_emitted, assert_events_emitted_match, assert_events_eq, assert_no_events,

36

	AtStake, Bond, CollatorStatus, DelegationScheduledRequests,

37

	DelegationScheduledRequestsPerCollator, DelegatorAdded, EnableMarkingOffline, Error, Event,

38

	FreezeReason, InflationDistributionInfo, Range, WasInactive,

39

};

40

use frame_support::migrations::SteppedMigration;

41

use frame_support::storage::storage_prefix;

42

use frame_support::traits::fungible::MutateFreeze;

43

use frame_support::traits::{Currency, ExistenceRequirement, WithdrawReasons};

44

use frame_support::weights::WeightMeter;

45

use frame_support::{assert_noop, assert_ok, BoundedVec};

46

use pallet_balances::{Event as BalancesEvent, PositiveImbalance};

47

use parity_scale_codec::{Decode, Encode};

48

use sp_io::hashing::blake2_128;

49

use sp_runtime::{traits::Zero, DispatchError, ModuleError, Perbill, Percent, RuntimeDebug};

50

51

#[test]

52

1

fn invalid_root_origin_fails() {

53

1

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

54

1

		assert_noop!(

55

1

			ParachainStaking::set_total_selected(RuntimeOrigin::signed(45), 6u32),

56

1

			sp_runtime::DispatchError::BadOrigin

57

);

58

1

		assert_noop!(

59

1

			ParachainStaking::set_collator_commission(

60

1

				RuntimeOrigin::signed(45),

61

1

				Perbill::from_percent(5)

62

),

63

1

			sp_runtime::DispatchError::BadOrigin

64

);

65

1

		assert_noop!(

66

1

			ParachainStaking::set_blocks_per_round(RuntimeOrigin::signed(45), 3u32),

67

1

			sp_runtime::DispatchError::BadOrigin

68

);

69

1

});

70

1

71

72

// SET TOTAL SELECTED

73

74

#[test]

75

1

fn set_total_selected_event_emits_correctly() {

76

1

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

77

		// before we can bump total_selected we must bump the blocks per round

78

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

79

1

			RuntimeOrigin::root(),

80

			7u32

81

));

82

1

		roll_blocks(1);

83

1

		assert_ok!(ParachainStaking::set_total_selected(

84

1

			RuntimeOrigin::root(),

85

			6u32

86

));

87

1

		assert_events_eq!(Event::TotalSelectedSet {

88

1

			old: 5u32,

89

1

			new: 6u32

90

1

});

91

1

});

92

1

93

94

#[test]

95

1

fn set_total_selected_fails_if_above_blocks_per_round() {

96

1

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

97

1

		assert_eq!(ParachainStaking::round().length, 5); // test relies on this

98

1

		assert_noop!(

99

1

			ParachainStaking::set_total_selected(RuntimeOrigin::root(), 6u32),

100

1

			Error::<Test>::RoundLengthMustBeGreaterThanTotalSelectedCollators,

101

);

102

1

});

103

1

104

105

#[test]

106

1

fn set_total_selected_fails_if_above_max_candidates() {

107

1

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

108

1

		assert_eq!(<Test as crate::Config>::MaxCandidates::get(), 200); // test relies on this

109

1

		assert_noop!(

110

1

			ParachainStaking::set_total_selected(RuntimeOrigin::root(), 201u32),

111

1

			Error::<Test>::CannotSetAboveMaxCandidates,

112

);

113

1

});

114

1

115

116

#[test]

117

1

fn set_total_selected_fails_if_equal_to_blocks_per_round() {

118

1

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

119

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

120

1

			RuntimeOrigin::root(),

121

			10u32

122

));

123

1

		assert_noop!(

124

1

			ParachainStaking::set_total_selected(RuntimeOrigin::root(), 10u32),

125

1

			Error::<Test>::RoundLengthMustBeGreaterThanTotalSelectedCollators,

126

);

127

1

});

128

1

129

130

#[test]

131

1

fn set_total_selected_passes_if_below_blocks_per_round() {

132

1

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

133

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

134

1

			RuntimeOrigin::root(),

135

			10u32

136

));

137

1

		assert_ok!(ParachainStaking::set_total_selected(

138

1

			RuntimeOrigin::root(),

139

			9u32

140

));

141

1

});

142

1

143

144

#[test]

145

1

fn set_blocks_per_round_fails_if_below_total_selected() {

146

1

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

147

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

148

1

			RuntimeOrigin::root(),

149

			20u32

150

));

151

1

		assert_ok!(ParachainStaking::set_total_selected(

152

1

			RuntimeOrigin::root(),

153

			10u32

154

));

155

1

		assert_noop!(

156

1

			ParachainStaking::set_blocks_per_round(RuntimeOrigin::root(), 9u32),

157

1

			Error::<Test>::RoundLengthMustBeGreaterThanTotalSelectedCollators,

158

);

159

1

});

160

1

161

162

#[test]

163

1

fn set_blocks_per_round_fails_if_equal_to_total_selected() {

164

1

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

165

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

166

1

			RuntimeOrigin::root(),

167

			10u32

168

));

169

1

		assert_ok!(ParachainStaking::set_total_selected(

170

1

			RuntimeOrigin::root(),

171

			9u32

172

));

173

1

		assert_noop!(

174

1

			ParachainStaking::set_blocks_per_round(RuntimeOrigin::root(), 9u32),

175

1

			Error::<Test>::RoundLengthMustBeGreaterThanTotalSelectedCollators,

176

);

177

1

});

178

1

179

180

#[test]

181

1

fn set_blocks_per_round_passes_if_above_total_selected() {

182

1

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

183

1

		assert_eq!(ParachainStaking::round().length, 5); // test relies on this

184

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

185

1

			RuntimeOrigin::root(),

186

			6u32

187

));

188

1

});

189

1

190

191

#[test]

192

1

fn set_total_selected_storage_updates_correctly() {

193

1

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

194

		// round length must be >= total_selected, so update that first

195

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

196

1

			RuntimeOrigin::root(),

197

			10u32

198

));

199

200

1

		assert_eq!(ParachainStaking::total_selected(), 5u32);

201

1

		assert_ok!(ParachainStaking::set_total_selected(

202

1

			RuntimeOrigin::root(),

203

			6u32

204

));

205

1

		assert_eq!(ParachainStaking::total_selected(), 6u32);

206

1

});

207

1

208

209

#[test]

210

1

fn cannot_set_total_selected_to_current_total_selected() {

211

1

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

212

1

		assert_noop!(

213

1

			ParachainStaking::set_total_selected(RuntimeOrigin::root(), 5u32),

214

1

			Error::<Test>::NoWritingSameValue

215

);

216

1

});

217

1

218

219

#[test]

220

1

fn cannot_set_total_selected_below_module_min() {

221

1

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

222

1

		assert_noop!(

223

1

			ParachainStaking::set_total_selected(RuntimeOrigin::root(), 4u32),

224

1

			Error::<Test>::CannotSetBelowMin

225

);

226

1

});

227

1

228

229

// SET COLLATOR COMMISSION

230

231

#[test]

232

1

fn set_collator_commission_event_emits_correctly() {

233

1

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

234

1

		assert_ok!(ParachainStaking::set_collator_commission(

235

1

			RuntimeOrigin::root(),

236

1

			Perbill::from_percent(5)

237

));

238

1

		assert_events_eq!(Event::CollatorCommissionSet {

239

1

			old: Perbill::from_percent(20),

240

1

			new: Perbill::from_percent(5),

241

1

});

242

1

});

243

1

244

245

#[test]

246

1

fn set_collator_commission_storage_updates_correctly() {

247

1

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

248

1

		assert_eq!(

249

1

			ParachainStaking::collator_commission(),

250

1

			Perbill::from_percent(20)

251

);

252

1

		assert_ok!(ParachainStaking::set_collator_commission(

253

1

			RuntimeOrigin::root(),

254

1

			Perbill::from_percent(5)

255

));

256

1

		assert_eq!(

257

1

			ParachainStaking::collator_commission(),

258

1

			Perbill::from_percent(5)

259

);

260

1

});

261

1

262

263

#[test]

264

1

fn cannot_set_collator_commission_to_current_collator_commission() {

265

1

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

266

1

		assert_noop!(

267

1

			ParachainStaking::set_collator_commission(

268

1

				RuntimeOrigin::root(),

269

1

				Perbill::from_percent(20)

270

),

271

1

			Error::<Test>::NoWritingSameValue

272

);

273

1

});

274

1

275

276

// SET BLOCKS PER ROUND

277

278

#[test]

279

1

fn set_blocks_per_round_event_emits_correctly() {

280

1

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

281

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

282

1

			RuntimeOrigin::root(),

283

			6u32

284

));

285

1

		assert_events_eq!(Event::BlocksPerRoundSet {

286

1

			current_round: 1,

287

1

			first_block: 0,

288

1

			old: 5,

289

1

			new: 6,

290

1

			new_per_round_inflation_min: Perbill::from_parts(463),

291

1

			new_per_round_inflation_ideal: Perbill::from_parts(463),

292

1

			new_per_round_inflation_max: Perbill::from_parts(463),

293

1

});

294

1

});

295

1

296

297

#[test]

298

1

fn set_blocks_per_round_storage_updates_correctly() {

299

1

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

300

1

		assert_eq!(ParachainStaking::round().length, 5);

301

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

302

1

			RuntimeOrigin::root(),

303

			6u32

304

));

305

1

		assert_eq!(ParachainStaking::round().length, 6);

306

1

});

307

1

308

309

#[test]

310

1

fn cannot_set_blocks_per_round_below_module_min() {

311

1

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

312

1

		assert_noop!(

313

1

			ParachainStaking::set_blocks_per_round(RuntimeOrigin::root(), 2u32),

314

1

			Error::<Test>::CannotSetBelowMin

315

);

316

1

});

317

1

318

319

#[test]

320

1

fn cannot_set_blocks_per_round_to_current_blocks_per_round() {

321

1

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

322

1

		assert_noop!(

323

1

			ParachainStaking::set_blocks_per_round(RuntimeOrigin::root(), 5u32),

324

1

			Error::<Test>::NoWritingSameValue

325

);

326

1

});

327

1

328

329

#[test]

330

1

fn round_immediately_jumps_if_current_duration_exceeds_new_blocks_per_round() {

331

1

	ExtBuilder::default()

332

1

		.with_balances(vec![(1, 20)])

333

1

		.with_candidates(vec![(1, 20)])

334

1

		.build()

335

1

		.execute_with(|| {

336

			// we can't lower the blocks per round because it must be above the number of collators,

337

			// and we can't lower the number of collators because it must be above

338

			// MinSelectedCandidates. so we first raise blocks per round, then lower it.

339

1

			assert_ok!(ParachainStaking::set_blocks_per_round(

340

1

				RuntimeOrigin::root(),

341

				10u32

342

));

343

344

1

			roll_to(10);

345

1

			assert_events_emitted!(Event::NewRound {

346

1

				starting_block: 10,

347

1

				round: 2,

348

1

				selected_collators_number: 1,

349

1

				total_balance: 20

350

1

			},);

351

1

			roll_to(17);

352

1

			assert_ok!(ParachainStaking::set_blocks_per_round(

353

1

				RuntimeOrigin::root(),

354

				6u32

355

));

356

1

			roll_to(18);

357

1

			assert_events_emitted!(Event::NewRound {

358

1

				starting_block: 18,

359

1

				round: 3,

360

1

				selected_collators_number: 1,

361

1

				total_balance: 20

362

1

});

363

1

});

364

1

365

366

// ~~ MONETARY GOVERNANCE ~~

367

368

#[test]

369

1

fn invalid_monetary_origin_fails() {

370

1

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

371

1

		assert_noop!(

372

1

			ParachainStaking::set_staking_expectations(

373

1

				RuntimeOrigin::signed(45),

374

1

				Range {

375

1

					min: 3u32.into(),

376

1

					ideal: 4u32.into(),

377

1

					max: 5u32.into()

378

1

379

),

380

1

			sp_runtime::DispatchError::BadOrigin

381

);

382

1

		assert_noop!(

383

1

			ParachainStaking::set_inflation(

384

1

				RuntimeOrigin::signed(45),

385

1

				Range {

386

1

					min: Perbill::from_percent(3),

387

1

					ideal: Perbill::from_percent(4),

388

1

					max: Perbill::from_percent(5)

389

1

390

),

391

1

			sp_runtime::DispatchError::BadOrigin

392

);

393

1

		assert_noop!(

394

1

			ParachainStaking::set_inflation(

395

1

				RuntimeOrigin::signed(45),

396

1

				Range {

397

1

					min: Perbill::from_percent(3),

398

1

					ideal: Perbill::from_percent(4),

399

1

					max: Perbill::from_percent(5)

400

1

401

),

402

1

			sp_runtime::DispatchError::BadOrigin

403

);

404

1

		assert_noop!(

405

1

			ParachainStaking::set_inflation_distribution_config(

406

1

				RuntimeOrigin::signed(45),

407

1

				inflation_configs(1, 50, 2, 30)

408

),

409

1

			sp_runtime::DispatchError::BadOrigin

410

);

411

1

});

412

1

413

414

// SET STAKING EXPECTATIONS

415

416

#[test]

417

1

fn set_staking_event_emits_event_correctly() {

418

1

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

419

		// valid call succeeds

420

1

		assert_ok!(ParachainStaking::set_staking_expectations(

421

1

			RuntimeOrigin::root(),

422

1

			Range {

423

1

				min: 3u128,

424

1

				ideal: 4u128,

425

1

				max: 5u128,

426

1

427

));

428

1

		assert_events_eq!(Event::StakeExpectationsSet {

429

1

			expect_min: 3u128,

430

1

			expect_ideal: 4u128,

431

1

			expect_max: 5u128,

432

1

});

433

1

});

434

1

435

436

#[test]

437

1

fn set_staking_updates_storage_correctly() {

438

1

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

439

1

		assert_eq!(

440

1

			ParachainStaking::inflation_config().expect,

441

			Range {

442

				min: 700,

443

				ideal: 700,

444

				max: 700

445

446

);

447

1

		assert_ok!(ParachainStaking::set_staking_expectations(

448

1

			RuntimeOrigin::root(),

449

1

			Range {

450

1

				min: 3u128,

451

1

				ideal: 4u128,

452

1

				max: 5u128,

453

1

454

));

455

1

		assert_eq!(

456

1

			ParachainStaking::inflation_config().expect,

457

			Range {

458

				min: 3u128,

459

				ideal: 4u128,

460

				max: 5u128

461

462

);

463

1

});

464

1

465

466

#[test]

467

1

fn cannot_set_invalid_staking_expectations() {

468

1

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

469

		// invalid call fails

470

1

		assert_noop!(

471

1

			ParachainStaking::set_staking_expectations(

472

1

				RuntimeOrigin::root(),

473

1

				Range {

474

1

					min: 5u128,

475

1

					ideal: 4u128,

476

1

					max: 3u128

477

1

478

),

479

1

			Error::<Test>::InvalidSchedule

480

);

481

1

});

482

1

483

484

#[test]

485

1

fn cannot_set_same_staking_expectations() {

486

1

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

487

1

		assert_ok!(ParachainStaking::set_staking_expectations(

488

1

			RuntimeOrigin::root(),

489

1

			Range {

490

1

				min: 3u128,

491

1

				ideal: 4u128,

492

1

				max: 5u128

493

1

494

));

495

1

		assert_noop!(

496

1

			ParachainStaking::set_staking_expectations(

497

1

				RuntimeOrigin::root(),

498

1

				Range {

499

1

					min: 3u128,

500

1

					ideal: 4u128,

501

1

					max: 5u128

502

1

503

),

504

1

			Error::<Test>::NoWritingSameValue

505

);

506

1

});

507

1

508

509

// SET INFLATION

510

511

#[test]

512

1

fn set_inflation_event_emits_correctly() {

513

1

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

514

1

		let (min, ideal, max): (Perbill, Perbill, Perbill) = (

515

1

			Perbill::from_percent(3),

516

1

			Perbill::from_percent(4),

517

1

			Perbill::from_percent(5),

518

1

);

519

1

		assert_ok!(ParachainStaking::set_inflation(

520

1

			RuntimeOrigin::root(),

521

1

			Range { min, ideal, max }

522

));

523

1

		assert_events_eq!(Event::InflationSet {

524

1

			annual_min: min,

525

1

			annual_ideal: ideal,

526

1

			annual_max: max,

527

1

			round_min: Perbill::from_parts(29),

528

1

			round_ideal: Perbill::from_parts(38),

529

1

			round_max: Perbill::from_parts(47),

530

1

});

531

1

});

532

1

533

534

#[test]

535

1

fn set_inflation_storage_updates_correctly() {

536

1

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

537

1

		let (min, ideal, max): (Perbill, Perbill, Perbill) = (

538

1

			Perbill::from_percent(3),

539

1

			Perbill::from_percent(4),

540

1

			Perbill::from_percent(5),

541

1

);

542

1

		assert_eq!(

543

1

			ParachainStaking::inflation_config().annual,

544

1

			Range {

545

1

				min: Perbill::from_percent(50),

546

1

				ideal: Perbill::from_percent(50),

547

1

				max: Perbill::from_percent(50)

548

1

549

);

550

1

		assert_eq!(

551

1

			ParachainStaking::inflation_config().round,

552

1

			Range {

553

1

				min: Perbill::from_percent(5),

554

1

				ideal: Perbill::from_percent(5),

555

1

				max: Perbill::from_percent(5)

556

1

557

);

558

1

		assert_ok!(ParachainStaking::set_inflation(

559

1

			RuntimeOrigin::root(),

560

1

			Range { min, ideal, max }

561

		),);

562

1

		assert_eq!(

563

1

			ParachainStaking::inflation_config().annual,

564

1

			Range { min, ideal, max }

565

);

566

1

		assert_eq!(

567

1

			ParachainStaking::inflation_config().round,

568

1

			Range {

569

1

				min: Perbill::from_parts(29),

570

1

				ideal: Perbill::from_parts(38),

571

1

				max: Perbill::from_parts(47)

572

1

573

);

574

1

});

575

1

576

577

#[test]

578

1

fn cannot_set_invalid_inflation() {

579

1

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

580

1

		assert_noop!(

581

1

			ParachainStaking::set_inflation(

582

1

				RuntimeOrigin::root(),

583

1

				Range {

584

1

					min: Perbill::from_percent(5),

585

1

					ideal: Perbill::from_percent(4),

586

1

					max: Perbill::from_percent(3)

587

1

588

),

589

1

			Error::<Test>::InvalidSchedule

590

);

591

1

});

592

1

593

594

#[test]

595

1

fn cannot_set_same_inflation() {

596

1

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

597

1

		let (min, ideal, max): (Perbill, Perbill, Perbill) = (

598

1

			Perbill::from_percent(3),

599

1

			Perbill::from_percent(4),

600

1

			Perbill::from_percent(5),

601

1

);

602

1

		assert_ok!(ParachainStaking::set_inflation(

603

1

			RuntimeOrigin::root(),

604

1

			Range { min, ideal, max }

605

		),);

606

1

		assert_noop!(

607

1

			ParachainStaking::set_inflation(RuntimeOrigin::root(), Range { min, ideal, max }),

608

1

			Error::<Test>::NoWritingSameValue

609

);

610

1

});

611

1

612

613

#[test]

614

1

fn set_inflation_distribution_config_event_emits_correctly() {

615

1

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

616

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

617

1

			RuntimeOrigin::root(),

618

1

			inflation_configs(1, 30, 2, 20),

619

));

620

1

		assert_events_eq!(Event::InflationDistributionConfigUpdated {

621

1

			old: inflation_configs(0, 30, 0, 0),

622

1

			new: inflation_configs(1, 30, 2, 20),

623

1

});

624

1

		roll_blocks(1);

625

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

626

1

			RuntimeOrigin::root(),

627

1

			inflation_configs(5, 10, 6, 5),

628

));

629

1

		assert_events_eq!(Event::InflationDistributionConfigUpdated {

630

1

			old: inflation_configs(1, 30, 2, 20),

631

1

			new: inflation_configs(5, 10, 6, 5),

632

1

});

633

1

});

634

1

635

636

#[test]

637

1

fn set_inflation_distribution_config_storage_updates_correctly() {

638

1

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

639

1

		assert_eq!(

640

1

			InflationDistributionInfo::<Test>::get(),

641

1

			inflation_configs(0, 30, 0, 0),

642

);

643

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

644

1

			RuntimeOrigin::root(),

645

1

			inflation_configs(5, 10, 6, 5),

646

));

647

1

		assert_eq!(

648

1

			InflationDistributionInfo::<Test>::get(),

649

1

			inflation_configs(5, 10, 6, 5),

650

);

651

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

652

1

			RuntimeOrigin::root(),

653

1

			inflation_configs(1, 30, 2, 20),

654

));

655

1

		assert_eq!(

656

1

			InflationDistributionInfo::<Test>::get(),

657

1

			inflation_configs(1, 30, 2, 20),

658

);

659

1

});

660

1

661

662

#[test]

663

1

fn cannot_set_same_inflation_distribution_config() {

664

1

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

665

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

666

1

			RuntimeOrigin::root(),

667

1

			inflation_configs(1, 30, 2, 20),

668

));

669

1

		assert_noop!(

670

1

			ParachainStaking::set_inflation_distribution_config(

671

1

				RuntimeOrigin::root(),

672

1

				inflation_configs(1, 30, 2, 20)

673

),

674

1

			Error::<Test>::NoWritingSameValue,

675

);

676

1

});

677

1

678

679

#[test]

680

1

fn sum_of_inflation_distribution_config_percentages_must_lte_100() {

681

1

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

682

1

		let invalid_values: Vec<(u8, u8)> = vec![

683

1

			(20, 90),

684

1

			(90, 20),

685

1

			(50, 51),

686

1

			(100, 1),

687

1

			(1, 100),

688

1

			(55, 55),

689

1

			(2, 99),

690

1

			(100, 100),

691

];

692

693

9

		for (pbr_percentage, treasury_percentage) in invalid_values {

694

8

			assert_noop!(

695

8

				ParachainStaking::set_inflation_distribution_config(

696

8

					RuntimeOrigin::root(),

697

8

					inflation_configs(1, pbr_percentage, 2, treasury_percentage),

698

),

699

8

				Error::<Test>::TotalInflationDistributionPercentExceeds100,

700

);

701

702

703

1

		let valid_values: Vec<(u8, u8)> = vec![

704

1

			(0, 100),

705

1

			(100, 0),

706

1

			(0, 0),

707

1

			(100, 0),

708

1

			(0, 100),

709

1

			(50, 50),

710

1

			(1, 99),

711

1

			(99, 1),

712

1

			(1, 1),

713

1

			(10, 20),

714

1

			(34, 32),

715

1

			(15, 10),

716

];

717

718

13

		for (pbr_percentage, treasury_percentage) in valid_values {

719

12

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

720

12

				RuntimeOrigin::root(),

721

12

				inflation_configs(1, pbr_percentage, 2, treasury_percentage),

722

));

723

724

1

});

725

1

726

727

// ~~ PUBLIC ~~

728

729

// JOIN CANDIDATES

730

731

#[test]

732

1

fn join_candidates_event_emits_correctly() {

733

1

	ExtBuilder::default()

734

1

		.with_balances(vec![(1, 10)])

735

1

		.build()

736

1

		.execute_with(|| {

737

1

			assert_ok!(ParachainStaking::join_candidates(

738

1

				RuntimeOrigin::signed(1),

739

				10u128,

740

				0u32

741

));

742

1

			assert_events_eq!(Event::JoinedCollatorCandidates {

743

1

				account: 1,

744

1

				amount_locked: 10u128,

745

1

				new_total_amt_locked: 10u128,

746

1

});

747

1

});

748

1

749

750

#[test]

751

1

fn join_candidates_reserves_balance() {

752

1

	ExtBuilder::default()

753

1

		.with_balances(vec![(1, 10)])

754

1

		.build()

755

1

		.execute_with(|| {

756

1

			assert_eq!(ParachainStaking::get_collator_stakable_free_balance(&1), 10);

757

1

			assert_ok!(ParachainStaking::join_candidates(

758

1

				RuntimeOrigin::signed(1),

759

				10u128,

760

				0u32

761

));

762

1

			assert_eq!(ParachainStaking::get_collator_stakable_free_balance(&1), 0);

763

1

});

764

1

765

766

#[test]

767

1

fn join_candidates_increases_total_staked() {

768

1

	ExtBuilder::default()

769

1

		.with_balances(vec![(1, 10)])

770

1

		.build()

771

1

		.execute_with(|| {

772

1

			assert_eq!(ParachainStaking::total(), 0);

773

1

			assert_ok!(ParachainStaking::join_candidates(

774

1

				RuntimeOrigin::signed(1),

775

				10u128,

776

				0u32

777

));

778

1

			assert_eq!(ParachainStaking::total(), 10);

779

1

});

780

1

781

782

#[test]

783

1

fn join_candidates_creates_candidate_state() {

784

1

	ExtBuilder::default()

785

1

		.with_balances(vec![(1, 10)])

786

1

		.build()

787

1

		.execute_with(|| {

788

1

			assert!(ParachainStaking::candidate_info(1).is_none());

789

1

			assert_ok!(ParachainStaking::join_candidates(

790

1

				RuntimeOrigin::signed(1),

791

				10u128,

792

				0u32

793

));

794

1

			let candidate_state =

795

1

				ParachainStaking::candidate_info(1).expect("just joined => exists");

796

1

			assert_eq!(candidate_state.bond, 10u128);

797

1

});

798

1

799

800

#[test]

801

1

fn join_candidates_adds_to_candidate_pool() {

802

1

	ExtBuilder::default()

803

1

		.with_balances(vec![(1, 10)])

804

1

		.build()

805

1

		.execute_with(|| {

806

1

			assert!(ParachainStaking::candidate_pool().0.is_empty());

807

1

			assert_ok!(ParachainStaking::join_candidates(

808

1

				RuntimeOrigin::signed(1),

809

				10u128,

810

				0u32

811

));

812

1

			let candidate_pool = ParachainStaking::candidate_pool();

813

1

			assert_eq!(candidate_pool.0[0].owner, 1);

814

1

			assert_eq!(candidate_pool.0[0].amount, 10);

815

1

});

816

1

817

818

#[test]

819

1

fn cannot_join_candidates_if_candidate() {

820

1

	ExtBuilder::default()

821

1

		.with_balances(vec![(1, 1000)])

822

1

		.with_candidates(vec![(1, 500)])

823

1

		.build()

824

1

		.execute_with(|| {

825

1

			assert_noop!(

826

1

				ParachainStaking::join_candidates(RuntimeOrigin::signed(1), 11u128, 100u32),

827

1

				Error::<Test>::CandidateExists

828

);

829

1

});

830

1

831

832

#[test]

833

1

fn cannot_join_candidates_if_delegator() {

834

1

	ExtBuilder::default()

835

1

		.with_balances(vec![(1, 50), (2, 20)])

836

1

		.with_candidates(vec![(1, 50)])

837

1

		.with_delegations(vec![(2, 1, 10)])

838

1

		.build()

839

1

		.execute_with(|| {

840

1

			assert_noop!(

841

1

				ParachainStaking::join_candidates(RuntimeOrigin::signed(2), 10u128, 1u32),

842

1

				Error::<Test>::DelegatorExists

843

);

844

1

});

845

1

846

847

#[test]

848

1

fn cannot_join_candidates_without_min_bond() {

849

1

	ExtBuilder::default()

850

1

		.with_balances(vec![(1, 1000)])

851

1

		.build()

852

1

		.execute_with(|| {

853

1

			assert_noop!(

854

1

				ParachainStaking::join_candidates(RuntimeOrigin::signed(1), 9u128, 100u32),

855

1

				Error::<Test>::CandidateBondBelowMin

856

);

857

1

});

858

1

859

860

#[test]

861

1

fn can_force_join_candidates_without_min_bond() {

862

1

	ExtBuilder::default()

863

1

		.with_balances(vec![(1, 10)])

864

1

		.build()

865

1

		.execute_with(|| {

866

1

			assert_ok!(ParachainStaking::force_join_candidates(

867

1

				RuntimeOrigin::root(),

868

1,

869

9,

870

				100u32

871

));

872

1

			assert_events_eq!(Event::JoinedCollatorCandidates {

873

1

				account: 1,

874

1

				amount_locked: 9u128,

875

1

				new_total_amt_locked: 9u128,

876

1

});

877

1

});

878

1

879

880

#[test]

881

1

fn cannot_join_candidates_with_more_than_available_balance() {

882

1

	ExtBuilder::default()

883

1

		.with_balances(vec![(1, 500)])

884

1

		.build()

885

1

		.execute_with(|| {

886

1

			assert_noop!(

887

1

				ParachainStaking::join_candidates(RuntimeOrigin::signed(1), 501u128, 100u32),

888

1

				DispatchError::Module(ModuleError {

889

1

					index: 2,

890

1

					error: [8, 0, 0, 0],

891

1

					message: Some("InsufficientBalance")

892

1

})

893

);

894

1

});

895

1

896

897

#[test]

898

1

fn insufficient_join_candidates_weight_hint_fails() {

899

1

	ExtBuilder::default()

900

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20), (6, 20)])

901

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

902

1

		.build()

903

1

		.execute_with(|| {

904

6

			for i in 0..5 {

905

5

				assert_noop!(

906

5

					ParachainStaking::join_candidates(RuntimeOrigin::signed(6), 20, i),

907

5

					Error::<Test>::TooLowCandidateCountWeightHintJoinCandidates

908

);

909

910

1

});

911

1

912

913

#[test]

914

1

fn sufficient_join_candidates_weight_hint_succeeds() {

915

1

	ExtBuilder::default()

916

1

		.with_balances(vec![

917

1

			(1, 20),

918

1

			(2, 20),

919

1

			(3, 20),

920

1

			(4, 20),

921

1

			(5, 20),

922

1

			(6, 20),

923

1

			(7, 20),

924

1

			(8, 20),

925

1

			(9, 20),

926

1

])

927

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

928

1

		.build()

929

1

		.execute_with(|| {

930

1

			let mut count = 5u32;

931

5

			for i in 6..10 {

932

4

				assert_ok!(ParachainStaking::join_candidates(

933

4

					RuntimeOrigin::signed(i),

934

20,

935

4

					count

936

));

937

4

				count += 1u32;

938

939

1

});

940

1

941

942

#[test]

943

1

fn join_candidates_fails_if_above_max_candidate_count() {

944

1

	let mut candidates = vec![];

945

200

	for i in 1..=crate::mock::MaxCandidates::get() {

946

200

		candidates.push((i as u64, 80));

947

200

948

949

1

	let new_candidate = crate::mock::MaxCandidates::get() as u64 + 1;

950

1

	let mut balances = candidates.clone();

951

1

	balances.push((new_candidate, 100));

952

953

1

	ExtBuilder::default()

954

1

		.with_balances(balances)

955

1

		.with_candidates(candidates)

956

1

		.build()

957

1

		.execute_with(|| {

958

1

			assert_noop!(

959

1

				ParachainStaking::join_candidates(

960

1

					RuntimeOrigin::signed(new_candidate),

961

80,

962

1

					crate::mock::MaxCandidates::get(),

963

),

964

1

				Error::<Test>::CandidateLimitReached,

965

);

966

1

});

967

1

968

969

// SCHEDULE LEAVE CANDIDATES

970

971

#[test]

972

1

fn leave_candidates_event_emits_correctly() {

973

1

	ExtBuilder::default()

974

1

		.with_balances(vec![(1, 10)])

975

1

		.with_candidates(vec![(1, 10)])

976

1

		.build()

977

1

		.execute_with(|| {

978

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

979

1

				RuntimeOrigin::signed(1),

980

				1u32

981

));

982

1

			assert_events_eq!(Event::CandidateScheduledExit {

983

1

				exit_allowed_round: 1,

984

1

				candidate: 1,

985

1

				scheduled_exit: 3

986

1

});

987

1

});

988

1

989

990

#[test]

991

1

fn leave_candidates_removes_candidate_from_candidate_pool() {

992

1

	ExtBuilder::default()

993

1

		.with_balances(vec![(1, 10)])

994

1

		.with_candidates(vec![(1, 10)])

995

1

		.build()

996

1

		.execute_with(|| {

997

1

			assert_eq!(ParachainStaking::candidate_pool().0.len(), 1);

998

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

999

1

				RuntimeOrigin::signed(1),

1000

				1u32

1001

));

1002

1

			assert!(ParachainStaking::candidate_pool().0.is_empty());

1003

1

});

1004

1

1005

1006

#[test]

1007

1

fn cannot_leave_candidates_if_not_candidate() {

1008

1

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

1009

1

		assert_noop!(

1010

1

			ParachainStaking::schedule_leave_candidates(RuntimeOrigin::signed(1), 1u32),

1011

1

			Error::<Test>::CandidateDNE

1012

);

1013

1

});

1014

1

1015

1016

#[test]

1017

1

fn cannot_leave_candidates_if_already_leaving_candidates() {

1018

1

	ExtBuilder::default()

1019

1

		.with_balances(vec![(1, 10)])

1020

1

		.with_candidates(vec![(1, 10)])

1021

1

		.build()

1022

1

		.execute_with(|| {

1023

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1024

1

				RuntimeOrigin::signed(1),

1025

				1u32

1026

));

1027

1

			assert_noop!(

1028

1

				ParachainStaking::schedule_leave_candidates(RuntimeOrigin::signed(1), 1u32),

1029

1

				Error::<Test>::CandidateAlreadyLeaving

1030

);

1031

1

});

1032

1

1033

1034

#[test]

1035

1

fn insufficient_leave_candidates_weight_hint_fails() {

1036

1

	ExtBuilder::default()

1037

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1038

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1039

1

		.build()

1040

1

		.execute_with(|| {

1041

6

			for i in 1..6 {

1042

5

				assert_noop!(

1043

5

					ParachainStaking::schedule_leave_candidates(RuntimeOrigin::signed(i), 4u32),

1044

5

					Error::<Test>::TooLowCandidateCountToLeaveCandidates

1045

);

1046

1047

1

});

1048

1

1049

1050

#[test]

1051

1

fn enable_marking_offline_works() {

1052

1

	ExtBuilder::default()

1053

1

		.with_balances(vec![(1, 20)])

1054

1

		.build()

1055

1

		.execute_with(|| {

1056

1

			assert_ok!(ParachainStaking::enable_marking_offline(

1057

1

				RuntimeOrigin::root(),

1058

				true

1059

));

1060

1

			assert!(ParachainStaking::marking_offline());

1061

1062

			// Set to false now

1063

1

			assert_ok!(ParachainStaking::enable_marking_offline(

1064

1

				RuntimeOrigin::root(),

1065

				false

1066

));

1067

1

			assert!(!ParachainStaking::marking_offline());

1068

1

});

1069

1

1070

1071

#[test]

1072

1

fn enable_marking_offline_fails_bad_origin() {

1073

1

	ExtBuilder::default()

1074

1

		.with_balances(vec![(1, 20)])

1075

1

		.build()

1076

1

		.execute_with(|| {

1077

1

			assert_noop!(

1078

1

				ParachainStaking::enable_marking_offline(RuntimeOrigin::signed(1), true),

1079

1

				sp_runtime::DispatchError::BadOrigin

1080

);

1081

1

});

1082

1

1083

1084

#[test]

1085

1

fn was_inactive_is_cleaned_up_after_max_offline_rounds() {

1086

	const ACTIVE_COLLATOR: AccountId = 1;

1087

	const INACTIVE_COLLATOR: AccountId = 2;

1088

1089

1

	ExtBuilder::default()

1090

1

		.with_balances(vec![(1, 20), (2, 20)])

1091

1

		.with_candidates(vec![(1, 20), (2, 20)])

1092

1

		.build()

1093

1

		.execute_with(|| {

1094

1

			assert_eq!(<Test as crate::Config>::MaxOfflineRounds::get(), 2);

1095

1

			assert_eq!(<Test as crate::Config>::RewardPaymentDelay::get(), 2);

1096

1097

			// ACTIVE_COLLATOR authors all the blocks

1098

1

			set_block_author(ACTIVE_COLLATOR);

1099

1100

			// Round 2

1101

1

			roll_to_round_begin(2);

1102

1103

1

			assert!(<AtStake<Test>>::contains_key(1, ACTIVE_COLLATOR));

1104

1

			assert!(!<WasInactive<Test>>::contains_key(1, ACTIVE_COLLATOR));

1105

1106

1

			assert!(<AtStake<Test>>::contains_key(1, INACTIVE_COLLATOR));

1107

1

			assert!(<WasInactive<Test>>::contains_key(1, INACTIVE_COLLATOR));

1108

1109

			// Round 3

1110

1

			roll_to_round_begin(3);

1111

1112

1

			assert!(<AtStake<Test>>::contains_key(2, ACTIVE_COLLATOR));

1113

1

			assert!(!<WasInactive<Test>>::contains_key(2, ACTIVE_COLLATOR));

1114

1115

1

			assert!(<AtStake<Test>>::contains_key(2, INACTIVE_COLLATOR));

1116

1

			assert!(<WasInactive<Test>>::contains_key(2, INACTIVE_COLLATOR));

1117

1118

			// End of round 3

1119

1

			roll_to_round_end(3);

1120

1121

1

			assert!(

1122

1

				!<AtStake<Test>>::contains_key(1, ACTIVE_COLLATOR),

1123

				"Active collator should have no stake in round 1 due to the distribution of rewards"

1124

);

1125

1

			assert!(

1126

1

				!<AtStake<Test>>::contains_key(1, INACTIVE_COLLATOR),

1127

				"Inactive collator should have no stake in round 1 due to the distribution of rewards"

1128

);

1129

1130

1

			assert!(

1131

1

				!<WasInactive<Test>>::contains_key(1, ACTIVE_COLLATOR),

1132

				"Active collator should not be in WasInactive for round 1"

1133

);

1134

1

			assert!(

1135

1

				<WasInactive<Test>>::contains_key(1, INACTIVE_COLLATOR),

1136

				"Inactive collator should still be in WasInactive for round 1"

1137

);

1138

1139

			// Round 4

1140

1

			roll_to_round_end(4);

1141

1142

1

			assert!(

1143

1

				!<WasInactive<Test>>::contains_key(1, INACTIVE_COLLATOR),

1144

				"Round 1 WasInactive should be cleaned up after MaxOfflineRounds"

1145

);

1146

1

			assert!(<WasInactive<Test>>::contains_key(2, INACTIVE_COLLATOR));

1147

1

			assert!(<WasInactive<Test>>::contains_key(3, INACTIVE_COLLATOR));

1148

1

});

1149

1

1150

1151

#[test]

1152

1

fn notify_inactive_collator_works() {

1153

	const INACTIVE_COLLATOR: AccountId = 1;

1154

	const ACTIVE_COLLATOR: AccountId = 2;

1155

1156

1

	ExtBuilder::default()

1157

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1158

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1159

1

		.build()

1160

1

		.execute_with(|| {

1161

			// Enable killswitch

1162

1

			<EnableMarkingOffline<Test>>::set(true);

1163

1164

1

			assert_eq!(<Test as crate::Config>::MaxOfflineRounds::get(), 2);

1165

1

			assert_eq!(<Test as crate::Config>::RewardPaymentDelay::get(), 2);

1166

1167

			// Round 2 - INACTIVE_COLLATOR authors blocks

1168

1

			set_block_author(INACTIVE_COLLATOR);

1169

1

			roll_to_round_begin(2);

1170

1171

			// Change block author

1172

1

			set_block_author(ACTIVE_COLLATOR);

1173

1174

			// INACTIVE_COLLATOR does not produce blocks on round 2 and 3

1175

1

			roll_to_round_begin(4);

1176

1

			roll_blocks(1);

1177

1178

			// On round 4 notify inactive collator

1179

1

			assert_ok!(ParachainStaking::notify_inactive_collator(

1180

1

				RuntimeOrigin::signed(1),

1181

				INACTIVE_COLLATOR

1182

));

1183

1184

			// Check the collator was marked as offline as it hasn't produced blocks

1185

1

			assert_events_eq!(Event::CandidateWentOffline {

1186

1

				candidate: INACTIVE_COLLATOR

1187

1

			},);

1188

1

});

1189

1

1190

1191

#[test]

1192

1

fn notify_inactive_collator_succeeds_even_after_rewards_are_distributed() {

1193

	const INACTIVE_COLLATOR: AccountId = 1;

1194

	const ACTIVE_COLLATOR: AccountId = 2;

1195

1196

1

	ExtBuilder::default()

1197

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1198

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1199

1

		.build()

1200

1

		.execute_with(|| {

1201

			// Enable killswitch

1202

1

			<EnableMarkingOffline<Test>>::set(true);

1203

1204

			// We need (strictly) more blocks per round than collators so rewards

1205

			// can be distributed before the end of a round

1206

1

			assert_ok!(ParachainStaking::set_blocks_per_round(

1207

1

				RuntimeOrigin::root(),

1208

				6u32

1209

));

1210

1211

			// ACTIVE_COLLATOR authors all the blocks while INACTIVE_COLLATOR stays inactive

1212

1

			set_block_author(ACTIVE_COLLATOR);

1213

1214

			// Round 2

1215

1

			roll_to_round_begin(2);

1216

1

			roll_blocks(1);

1217

1218

			// INACTIVE_COLLATOR has a stake in round 1

1219

1

			assert!(<AtStake<Test>>::contains_key(1, INACTIVE_COLLATOR));

1220

1221

			// Round 3

1222

1

			roll_to_round_begin(3);

1223

1

			roll_blocks(1);

1224

1225

			// INACTIVE_COLLATOR has a stake in round 2

1226

1

			assert!(<AtStake<Test>>::contains_key(2, INACTIVE_COLLATOR));

1227

1228

			// End of round 3

1229

1

			roll_to_round_end(3);

1230

1231

			// INACTIVE_COLLATOR has a no stake in round 1 anymore due to the distribution of rewards

1232

1

			assert!(!<AtStake<Test>>::contains_key(1, INACTIVE_COLLATOR));

1233

1234

			// Call 'notify_inactive_collator' extrinsic on INACTIVE_COLLATOR

1235

1

			assert_ok!(ParachainStaking::notify_inactive_collator(

1236

1

				RuntimeOrigin::signed(1),

1237

				INACTIVE_COLLATOR

1238

));

1239

1240

1

			assert_events_eq!(

1241

1

				Event::Rewarded {

1242

1

					account: 2,

1243

1

					rewards: 0,

1244

1

},

1245

1

				Event::CandidateWentOffline {

1246

1

					candidate: INACTIVE_COLLATOR

1247

1

},

1248

);

1249

1

});

1250

1

1251

1252

#[test]

1253

1

fn notify_inactive_collator_fails_too_low_collator_count() {

1254

1

	ExtBuilder::default()

1255

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20)])

1256

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20)])

1257

1

		.build()

1258

1

		.execute_with(|| {

1259

			// Enable killswitch

1260

1

			<EnableMarkingOffline<Test>>::set(true);

1261

1262

			// Round 4

1263

1

			roll_to_round_begin(4);

1264

1

			roll_blocks(1);

1265

1266

			// Call 'notify_inactive_collator' extrinsic

1267

1

			assert_noop!(

1268

1

				ParachainStaking::notify_inactive_collator(RuntimeOrigin::signed(1), 1),

1269

1

				Error::<Test>::TooLowCollatorCountToNotifyAsInactive

1270

);

1271

1

});

1272

1

1273

1274

#[test]

1275

1

fn notify_inactive_collator_fails_candidate_is_not_collator() {

1276

1

	ExtBuilder::default()

1277

1

		.with_balances(vec![(1, 80), (2, 80), (3, 80), (4, 80), (5, 80), (6, 20)])

1278

1

		.with_candidates(vec![(1, 80), (2, 80), (3, 80), (4, 80), (5, 80)])

1279

1

		.build()

1280

1

		.execute_with(|| {

1281

			// Enable killswitch

1282

1

			<EnableMarkingOffline<Test>>::set(true);

1283

1284

1

			set_block_author(1);

1285

1286

1

			roll_to_round_begin(2);

1287

1

			assert_events_eq!(

1288

1

				Event::CollatorChosen {

1289

1

					round: 2,

1290

1

					collator_account: 1,

1291

1

					total_exposed_amount: 80,

1292

1

},

1293

1

				Event::CollatorChosen {

1294

1

					round: 2,

1295

1

					collator_account: 2,

1296

1

					total_exposed_amount: 80,

1297

1

},

1298

1

				Event::CollatorChosen {

1299

1

					round: 2,

1300

1

					collator_account: 3,

1301

1

					total_exposed_amount: 80,

1302

1

},

1303

1

				Event::CollatorChosen {

1304

1

					round: 2,

1305

1

					collator_account: 4,

1306

1

					total_exposed_amount: 80,

1307

1

},

1308

1

				Event::CollatorChosen {

1309

1

					round: 2,

1310

1

					collator_account: 5,

1311

1

					total_exposed_amount: 80,

1312

1

},

1313

1

				Event::NewRound {

1314

1

					starting_block: 5,

1315

1

					round: 2,

1316

1

					selected_collators_number: 5,

1317

1

					total_balance: 400,

1318

1

},

1319

);

1320

1

			roll_blocks(1);

1321

1322

1

			assert_ok!(ParachainStaking::join_candidates(

1323

1

				RuntimeOrigin::signed(6),

1324

10,

1325

1326

));

1327

1328

			// Round 6

1329

1

			roll_to_round_begin(6);

1330

1

			assert_events_eq!(

1331

1

				Event::CollatorChosen {

1332

1

					round: 6,

1333

1

					collator_account: 1,

1334

1

					total_exposed_amount: 80,

1335

1

},

1336

1

				Event::CollatorChosen {

1337

1

					round: 6,

1338

1

					collator_account: 2,

1339

1

					total_exposed_amount: 80,

1340

1

},

1341

1

				Event::CollatorChosen {

1342

1

					round: 6,

1343

1

					collator_account: 3,

1344

1

					total_exposed_amount: 80,

1345

1

},

1346

1

				Event::CollatorChosen {

1347

1

					round: 6,

1348

1

					collator_account: 4,

1349

1

					total_exposed_amount: 80,

1350

1

},

1351

1

				Event::CollatorChosen {

1352

1

					round: 6,

1353

1

					collator_account: 5,

1354

1

					total_exposed_amount: 80,

1355

1

},

1356

1

				Event::NewRound {

1357

1

					starting_block: 25,

1358

1

					round: 6,

1359

1

					selected_collators_number: 5,

1360

1

					total_balance: 400,

1361

1

},

1362

);

1363

1

			roll_blocks(1);

1364

1365

			// A candidate cannot be notified as inactive if it hasn't been selected

1366

			// to produce blocks

1367

1

			assert_noop!(

1368

1

				ParachainStaking::notify_inactive_collator(RuntimeOrigin::signed(1), 6),

1369

1

				Error::<Test>::CannotBeNotifiedAsInactive

1370

);

1371

1

});

1372

1

1373

1374

#[test]

1375

1

fn notify_inactive_collator_fails_cannot_be_notified_as_inactive() {

1376

1

	ExtBuilder::default()

1377

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1378

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1379

1

		.build()

1380

1

		.execute_with(|| {

1381

			// Enable killswitch

1382

1

			<EnableMarkingOffline<Test>>::set(true);

1383

1384

			// Round 2

1385

1

			roll_to_round_begin(2);

1386

1387

			// Change block author

1388

1

			set_block_author(1);

1389

1390

			// Round 3

1391

1

			roll_to_round_begin(3);

1392

1

			roll_blocks(1);

1393

1394

			// Round 4

1395

1

			roll_to_round_begin(4);

1396

1

			roll_blocks(1);

1397

1398

			// Call 'notify_inactive_collator' extrinsic

1399

1

			assert_noop!(

1400

1

				ParachainStaking::notify_inactive_collator(RuntimeOrigin::signed(1), 1),

1401

1

				Error::<Test>::CannotBeNotifiedAsInactive

1402

);

1403

1

});

1404

1

1405

1406

#[test]

1407

1

fn notify_inactive_collator_fails_round_too_low() {

1408

1

	ExtBuilder::default()

1409

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1410

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1411

1

		.build()

1412

1

		.execute_with(|| {

1413

			// Enable killswitch

1414

1

			<EnableMarkingOffline<Test>>::set(true);

1415

1416

			// Round 1

1417

1

			roll_to_round_begin(1);

1418

1

			roll_blocks(1);

1419

1420

			// Call 'notify_inactive_collator' extrinsic

1421

1

			assert_noop!(

1422

1

				ParachainStaking::notify_inactive_collator(RuntimeOrigin::signed(1), 1),

1423

1

				Error::<Test>::CurrentRoundTooLow

1424

);

1425

1

});

1426

1

1427

1428

#[test]

1429

1

fn sufficient_leave_candidates_weight_hint_succeeds() {

1430

1

	ExtBuilder::default()

1431

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1432

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 20)])

1433

1

		.build()

1434

1

		.execute_with(|| {

1435

1

			let mut count = 5u32;

1436

6

			for i in 1..6 {

1437

5

				assert_ok!(ParachainStaking::schedule_leave_candidates(

1438

5

					RuntimeOrigin::signed(i),

1439

5

					count

1440

));

1441

5

				count -= 1u32;

1442

1443

1

});

1444

1

1445

1446

// EXECUTE LEAVE CANDIDATES

1447

1448

#[test]

1449

1

fn execute_leave_candidates_emits_event() {

1450

1

	ExtBuilder::default()

1451

1

		.with_balances(vec![(1, 10)])

1452

1

		.with_candidates(vec![(1, 10)])

1453

1

		.build()

1454

1

		.execute_with(|| {

1455

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1456

1

				RuntimeOrigin::signed(1),

1457

				1u32

1458

));

1459

1

			roll_to(10);

1460

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1461

1

				RuntimeOrigin::signed(1),

1462

1,

1463

1464

));

1465

1

			assert_events_emitted!(Event::CandidateLeft {

1466

1

				ex_candidate: 1,

1467

1

				unlocked_amount: 10,

1468

1

				new_total_amt_locked: 0

1469

1

});

1470

1

});

1471

1

1472

1473

#[test]

1474

1

fn execute_leave_candidates_callable_by_any_signed() {

1475

1

	ExtBuilder::default()

1476

1

		.with_balances(vec![(1, 10)])

1477

1

		.with_candidates(vec![(1, 10)])

1478

1

		.build()

1479

1

		.execute_with(|| {

1480

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1481

1

				RuntimeOrigin::signed(1),

1482

				1u32

1483

));

1484

1

			roll_to(10);

1485

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1486

1

				RuntimeOrigin::signed(2),

1487

1,

1488

1489

));

1490

1

});

1491

1

1492

1493

#[test]

1494

1

fn execute_leave_candidates_requires_correct_weight_hint() {

1495

1

	ExtBuilder::default()

1496

1

		.with_balances(vec![(1, 10), (2, 10), (3, 10), (4, 10)])

1497

1

		.with_candidates(vec![(1, 10)])

1498

1

		.with_delegations(vec![(2, 1, 10), (3, 1, 10), (4, 1, 10)])

1499

1

		.build()

1500

1

		.execute_with(|| {

1501

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1502

1

				RuntimeOrigin::signed(1),

1503

				1u32

1504

));

1505

1

			roll_to(10);

1506

4

			for i in 0..3 {

1507

3

				assert_noop!(

1508

3

					ParachainStaking::execute_leave_candidates(RuntimeOrigin::signed(1), 1, i),

1509

3

					Error::<Test>::TooLowCandidateDelegationCountToLeaveCandidates

1510

);

1511

1512

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1513

1

				RuntimeOrigin::signed(2),

1514

1,

1515

1516

));

1517

1

});

1518

1

1519

1520

#[test]

1521

1

fn execute_leave_candidates_unreserves_balance() {

1522

1

	ExtBuilder::default()

1523

1

		.with_balances(vec![(1, 10)])

1524

1

		.with_candidates(vec![(1, 10)])

1525

1

		.build()

1526

1

		.execute_with(|| {

1527

1

			assert_eq!(ParachainStaking::get_collator_stakable_free_balance(&1), 0);

1528

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1529

1

				RuntimeOrigin::signed(1),

1530

				1u32

1531

));

1532

1

			roll_to(10);

1533

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1534

1

				RuntimeOrigin::signed(1),

1535

1,

1536

1537

));

1538

1

			assert_eq!(ParachainStaking::get_collator_stakable_free_balance(&1), 10);

1539

1

});

1540

1

1541

1542

#[test]

1543

1

fn execute_leave_candidates_decreases_total_staked() {

1544

1

	ExtBuilder::default()

1545

1

		.with_balances(vec![(1, 10)])

1546

1

		.with_candidates(vec![(1, 10)])

1547

1

		.build()

1548

1

		.execute_with(|| {

1549

1

			assert_eq!(ParachainStaking::total(), 10);

1550

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1551

1

				RuntimeOrigin::signed(1),

1552

				1u32

1553

));

1554

1

			roll_to(10);

1555

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1556

1

				RuntimeOrigin::signed(1),

1557

1,

1558

1559

));

1560

1

			assert_eq!(ParachainStaking::total(), 0);

1561

1

});

1562

1

1563

1564

#[test]

1565

1

fn execute_leave_candidates_removes_candidate_state() {

1566

1

	ExtBuilder::default()

1567

1

		.with_balances(vec![(1, 10)])

1568

1

		.with_candidates(vec![(1, 10)])

1569

1

		.build()

1570

1

		.execute_with(|| {

1571

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1572

1

				RuntimeOrigin::signed(1),

1573

				1u32

1574

));

1575

			// candidate state is not immediately removed

1576

1

			let candidate_state =

1577

1

				ParachainStaking::candidate_info(1).expect("just left => still exists");

1578

1

			assert_eq!(candidate_state.bond, 10u128);

1579

1

			roll_to(10);

1580

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1581

1

				RuntimeOrigin::signed(1),

1582

1,

1583

1584

));

1585

1

			assert!(ParachainStaking::candidate_info(1).is_none());

1586

1

});

1587

1

1588

1589

#[test]

1590

1

fn execute_leave_candidates_removes_pending_delegation_requests() {

1591

1

	ExtBuilder::default()

1592

1

		.with_balances(vec![(1, 10), (2, 15)])

1593

1

		.with_candidates(vec![(1, 10)])

1594

1

		.with_delegations(vec![(2, 1, 15)])

1595

1

		.build()

1596

1

		.execute_with(|| {

1597

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

1598

1

				RuntimeOrigin::signed(2),

1599

1,

1600

1601

));

1602

1

			let state = ParachainStaking::delegation_scheduled_requests(&1, &2);

1603

1

			assert_eq!(

1604

				state,

1605

1

				vec![ScheduledRequest {

1606

1

					when_executable: 3,

1607

1

					action: DelegationAction::Decrease(5),

1608

1

}],

1609

);

1610

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1611

1

				RuntimeOrigin::signed(1),

1612

				1u32

1613

));

1614

			// candidate state is not immediately removed

1615

1

			let candidate_state =

1616

1

				ParachainStaking::candidate_info(1).expect("just left => still exists");

1617

1

			assert_eq!(candidate_state.bond, 10u128);

1618

1

			roll_to(10);

1619

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1620

1

				RuntimeOrigin::signed(1),

1621

1,

1622

1623

));

1624

1

			assert!(ParachainStaking::candidate_info(1).is_none());

1625

1

			assert!(

1626

1

				<DelegationScheduledRequests<Test>>::iter_prefix(1)

1627

1

					.next()

1628

1

					.is_none(),

1629

				"delegation requests were not removed for the candidate"

1630

);

1631

1

});

1632

1

1633

1634

#[test]

1635

1

fn cannot_execute_leave_candidates_before_delay() {

1636

1

	ExtBuilder::default()

1637

1

		.with_balances(vec![(1, 10)])

1638

1

		.with_candidates(vec![(1, 10)])

1639

1

		.build()

1640

1

		.execute_with(|| {

1641

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1642

1

				RuntimeOrigin::signed(1),

1643

				1u32

1644

));

1645

1

			assert_noop!(

1646

1

				ParachainStaking::execute_leave_candidates(RuntimeOrigin::signed(3), 1, 0)

1647

1

					.map_err(|err| err.error),

1648

1

				Error::<Test>::CandidateCannotLeaveYet

1649

);

1650

1

			roll_to(9);

1651

1

			assert_noop!(

1652

1

				ParachainStaking::execute_leave_candidates(RuntimeOrigin::signed(3), 1, 0)

1653

1

					.map_err(|err| err.error),

1654

1

				Error::<Test>::CandidateCannotLeaveYet

1655

);

1656

1

			roll_to(10);

1657

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1658

1

				RuntimeOrigin::signed(3),

1659

1,

1660

1661

));

1662

1

});

1663

1

1664

1665

// CANCEL LEAVE CANDIDATES

1666

1667

#[test]

1668

1

fn cancel_leave_candidates_emits_event() {

1669

1

	ExtBuilder::default()

1670

1

		.with_balances(vec![(1, 10)])

1671

1

		.with_candidates(vec![(1, 10)])

1672

1

		.build()

1673

1

		.execute_with(|| {

1674

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1675

1

				RuntimeOrigin::signed(1),

1676

				1u32

1677

));

1678

1

			assert_ok!(ParachainStaking::cancel_leave_candidates(

1679

1

				RuntimeOrigin::signed(1),

1680

1681

));

1682

1

			assert_events_emitted!(Event::CancelledCandidateExit { candidate: 1 });

1683

1

});

1684

1

1685

1686

#[test]

1687

1

fn cancel_leave_candidates_updates_candidate_state() {

1688

1

	ExtBuilder::default()

1689

1

		.with_balances(vec![(1, 10)])

1690

1

		.with_candidates(vec![(1, 10)])

1691

1

		.build()

1692

1

		.execute_with(|| {

1693

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1694

1

				RuntimeOrigin::signed(1),

1695

				1u32

1696

));

1697

1

			assert_ok!(ParachainStaking::cancel_leave_candidates(

1698

1

				RuntimeOrigin::signed(1),

1699

1700

));

1701

1

			let candidate =

1702

1

				ParachainStaking::candidate_info(&1).expect("just cancelled leave so exists");

1703

1

			assert!(candidate.is_active());

1704

1

});

1705

1

1706

1707

#[test]

1708

1

fn cancel_leave_candidates_adds_to_candidate_pool() {

1709

1

	ExtBuilder::default()

1710

1

		.with_balances(vec![(1, 10)])

1711

1

		.with_candidates(vec![(1, 10)])

1712

1

		.build()

1713

1

		.execute_with(|| {

1714

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1715

1

				RuntimeOrigin::signed(1),

1716

				1u32

1717

));

1718

1

			assert_ok!(ParachainStaking::cancel_leave_candidates(

1719

1

				RuntimeOrigin::signed(1),

1720

1721

));

1722

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].owner, 1);

1723

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].amount, 10);

1724

1

});

1725

1

1726

1727

// GO OFFLINE

1728

1729

#[test]

1730

1

fn go_offline_event_emits_correctly() {

1731

1

	ExtBuilder::default()

1732

1

		.with_balances(vec![(1, 20)])

1733

1

		.with_candidates(vec![(1, 20)])

1734

1

		.build()

1735

1

		.execute_with(|| {

1736

1

			assert_ok!(ParachainStaking::go_offline(RuntimeOrigin::signed(1)));

1737

1

			assert_events_eq!(Event::CandidateWentOffline { candidate: 1 });

1738

1

});

1739

1

1740

1741

#[test]

1742

1

fn go_offline_removes_candidate_from_candidate_pool() {

1743

1

	ExtBuilder::default()

1744

1

		.with_balances(vec![(1, 20)])

1745

1

		.with_candidates(vec![(1, 20)])

1746

1

		.build()

1747

1

		.execute_with(|| {

1748

1

			assert_eq!(ParachainStaking::candidate_pool().0.len(), 1);

1749

1

			assert_ok!(ParachainStaking::go_offline(RuntimeOrigin::signed(1)));

1750

1

			assert!(ParachainStaking::candidate_pool().0.is_empty());

1751

1

});

1752

1

1753

1754

#[test]

1755

1

fn go_offline_updates_candidate_state_to_idle() {

1756

1

	ExtBuilder::default()

1757

1

		.with_balances(vec![(1, 20)])

1758

1

		.with_candidates(vec![(1, 20)])

1759

1

		.build()

1760

1

		.execute_with(|| {

1761

1

			let candidate_state = ParachainStaking::candidate_info(1).expect("is active candidate");

1762

1

			assert_eq!(candidate_state.status, CollatorStatus::Active);

1763

1

			assert_ok!(ParachainStaking::go_offline(RuntimeOrigin::signed(1)));

1764

1

			let candidate_state =

1765

1

				ParachainStaking::candidate_info(1).expect("is candidate, just offline");

1766

1

			assert_eq!(candidate_state.status, CollatorStatus::Idle);

1767

1

});

1768

1

1769

1770

#[test]

1771

1

fn cannot_go_offline_if_not_candidate() {

1772

1

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

1773

1

		assert_noop!(

1774

1

			ParachainStaking::go_offline(RuntimeOrigin::signed(3)).map_err(|err| err.error),

1775

1

			Error::<Test>::CandidateDNE

1776

);

1777

1

});

1778

1

1779

1780

#[test]

1781

1

fn cannot_go_offline_if_already_offline() {

1782

1

	ExtBuilder::default()

1783

1

		.with_balances(vec![(1, 20)])

1784

1

		.with_candidates(vec![(1, 20)])

1785

1

		.build()

1786

1

		.execute_with(|| {

1787

1

			assert_ok!(ParachainStaking::go_offline(RuntimeOrigin::signed(1)));

1788

1

			assert_noop!(

1789

1

				ParachainStaking::go_offline(RuntimeOrigin::signed(1)).map_err(|err| err.error),

1790

1

				Error::<Test>::AlreadyOffline

1791

);

1792

1

});

1793

1

1794

1795

// GO ONLINE

1796

1797

#[test]

1798

1

fn go_online_event_emits_correctly() {

1799

1

	ExtBuilder::default()

1800

1

		.with_balances(vec![(1, 20)])

1801

1

		.with_candidates(vec![(1, 20)])

1802

1

		.build()

1803

1

		.execute_with(|| {

1804

1

			assert_ok!(ParachainStaking::go_offline(RuntimeOrigin::signed(1)));

1805

1

			roll_blocks(1);

1806

1

			assert_ok!(ParachainStaking::go_online(RuntimeOrigin::signed(1)));

1807

1

			assert_events_eq!(Event::CandidateBackOnline { candidate: 1 });

1808

1

});

1809

1

1810

1811

#[test]

1812

1

fn go_online_adds_to_candidate_pool() {

1813

1

	ExtBuilder::default()

1814

1

		.with_balances(vec![(1, 20)])

1815

1

		.with_candidates(vec![(1, 20)])

1816

1

		.build()

1817

1

		.execute_with(|| {

1818

1

			assert_ok!(ParachainStaking::go_offline(RuntimeOrigin::signed(1)));

1819

1

			assert!(ParachainStaking::candidate_pool().0.is_empty());

1820

1

			assert_ok!(ParachainStaking::go_online(RuntimeOrigin::signed(1)));

1821

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].owner, 1);

1822

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].amount, 20);

1823

1

});

1824

1

1825

1826

#[test]

1827

1

fn go_online_storage_updates_candidate_state() {

1828

1

	ExtBuilder::default()

1829

1

		.with_balances(vec![(1, 20)])

1830

1

		.with_candidates(vec![(1, 20)])

1831

1

		.build()

1832

1

		.execute_with(|| {

1833

1

			assert_ok!(ParachainStaking::go_offline(RuntimeOrigin::signed(1)));

1834

1

			let candidate_state =

1835

1

				ParachainStaking::candidate_info(1).expect("offline still exists");

1836

1

			assert_eq!(candidate_state.status, CollatorStatus::Idle);

1837

1

			assert_ok!(ParachainStaking::go_online(RuntimeOrigin::signed(1)));

1838

1

			let candidate_state = ParachainStaking::candidate_info(1).expect("online so exists");

1839

1

			assert_eq!(candidate_state.status, CollatorStatus::Active);

1840

1

});

1841

1

1842

1843

#[test]

1844

1

fn cannot_go_online_if_not_candidate() {

1845

1

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

1846

1

		assert_noop!(

1847

1

			ParachainStaking::go_online(RuntimeOrigin::signed(3)),

1848

1

			Error::<Test>::CandidateDNE

1849

);

1850

1

});

1851

1

1852

1853

#[test]

1854

1

fn cannot_go_online_if_already_online() {

1855

1

	ExtBuilder::default()

1856

1

		.with_balances(vec![(1, 20)])

1857

1

		.with_candidates(vec![(1, 20)])

1858

1

		.build()

1859

1

		.execute_with(|| {

1860

1

			assert_noop!(

1861

1

				ParachainStaking::go_online(RuntimeOrigin::signed(1)).map_err(|err| err.error),

1862

1

				Error::<Test>::AlreadyActive

1863

);

1864

1

});

1865

1

1866

1867

#[test]

1868

1

fn cannot_go_online_if_leaving() {

1869

1

	ExtBuilder::default()

1870

1

		.with_balances(vec![(1, 20)])

1871

1

		.with_candidates(vec![(1, 20)])

1872

1

		.build()

1873

1

		.execute_with(|| {

1874

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1875

1

				RuntimeOrigin::signed(1),

1876

1877

));

1878

1

			assert_noop!(

1879

1

				ParachainStaking::go_online(RuntimeOrigin::signed(1)).map_err(|err| err.error),

1880

1

				Error::<Test>::CannotGoOnlineIfLeaving

1881

);

1882

1

});

1883

1

1884

1885

// CANDIDATE BOND MORE

1886

1887

#[test]

1888

1

fn candidate_bond_more_emits_correct_event() {

1889

1

	ExtBuilder::default()

1890

1

		.with_balances(vec![(1, 50)])

1891

1

		.with_candidates(vec![(1, 20)])

1892

1

		.build()

1893

1

		.execute_with(|| {

1894

1

			assert_ok!(ParachainStaking::candidate_bond_more(

1895

1

				RuntimeOrigin::signed(1),

1896

1897

));

1898

1

			assert_events_eq!(Event::CandidateBondedMore {

1899

1

				candidate: 1,

1900

1

				amount: 30,

1901

1

				new_total_bond: 50

1902

1

});

1903

1

});

1904

1

1905

1906

#[test]

1907

1

fn candidate_bond_more_reserves_balance() {

1908

1

	ExtBuilder::default()

1909

1

		.with_balances(vec![(1, 50)])

1910

1

		.with_candidates(vec![(1, 20)])

1911

1

		.build()

1912

1

		.execute_with(|| {

1913

1

			assert_eq!(ParachainStaking::get_collator_stakable_free_balance(&1), 30);

1914

1

			assert_ok!(ParachainStaking::candidate_bond_more(

1915

1

				RuntimeOrigin::signed(1),

1916

1917

));

1918

1

			assert_eq!(ParachainStaking::get_collator_stakable_free_balance(&1), 0);

1919

1

});

1920

1

1921

1922

#[test]

1923

1

fn candidate_bond_more_increases_total() {

1924

1

	ExtBuilder::default()

1925

1

		.with_balances(vec![(1, 50)])

1926

1

		.with_candidates(vec![(1, 20)])

1927

1

		.build()

1928

1

		.execute_with(|| {

1929

1

			let mut total = ParachainStaking::total();

1930

1

			assert_ok!(ParachainStaking::candidate_bond_more(

1931

1

				RuntimeOrigin::signed(1),

1932

1933

));

1934

1

			total += 30;

1935

1

			assert_eq!(ParachainStaking::total(), total);

1936

1

});

1937

1

1938

1939

#[test]

1940

1

fn candidate_bond_more_updates_candidate_state() {

1941

1

	ExtBuilder::default()

1942

1

		.with_balances(vec![(1, 50)])

1943

1

		.with_candidates(vec![(1, 20)])

1944

1

		.build()

1945

1

		.execute_with(|| {

1946

1

			let candidate_state = ParachainStaking::candidate_info(1).expect("updated => exists");

1947

1

			assert_eq!(candidate_state.bond, 20);

1948

1

			assert_ok!(ParachainStaking::candidate_bond_more(

1949

1

				RuntimeOrigin::signed(1),

1950

1951

));

1952

1

			let candidate_state = ParachainStaking::candidate_info(1).expect("updated => exists");

1953

1

			assert_eq!(candidate_state.bond, 50);

1954

1

});

1955

1

1956

1957

#[test]

1958

1

fn candidate_bond_more_updates_candidate_pool() {

1959

1

	ExtBuilder::default()

1960

1

		.with_balances(vec![(1, 50)])

1961

1

		.with_candidates(vec![(1, 20)])

1962

1

		.build()

1963

1

		.execute_with(|| {

1964

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].owner, 1);

1965

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].amount, 20);

1966

1

			assert_ok!(ParachainStaking::candidate_bond_more(

1967

1

				RuntimeOrigin::signed(1),

1968

1969

));

1970

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].owner, 1);

1971

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].amount, 50);

1972

1

});

1973

1

1974

1975

// SCHEDULE CANDIDATE BOND LESS

1976

1977

#[test]

1978

1

fn schedule_candidate_bond_less_event_emits_correctly() {

1979

1

	ExtBuilder::default()

1980

1

		.with_balances(vec![(1, 30)])

1981

1

		.with_candidates(vec![(1, 30)])

1982

1

		.build()

1983

1

		.execute_with(|| {

1984

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

1985

1

				RuntimeOrigin::signed(1),

1986

1987

));

1988

1

			assert_events_eq!(Event::CandidateBondLessRequested {

1989

1

				candidate: 1,

1990

1

				amount_to_decrease: 10,

1991

1

				execute_round: 3,

1992

1

});

1993

1

});

1994

1

1995

1996

#[test]

1997

1

fn cannot_schedule_candidate_bond_less_if_request_exists() {

1998

1

	ExtBuilder::default()

1999

1

		.with_balances(vec![(1, 30)])

2000

1

		.with_candidates(vec![(1, 30)])

2001

1

		.build()

2002

1

		.execute_with(|| {

2003

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2004

1

				RuntimeOrigin::signed(1),

2005

2006

));

2007

1

			assert_noop!(

2008

1

				ParachainStaking::schedule_candidate_bond_less(RuntimeOrigin::signed(1), 5),

2009

1

				Error::<Test>::PendingCandidateRequestAlreadyExists

2010

);

2011

1

});

2012

1

2013

2014

#[test]

2015

1

fn cannot_schedule_candidate_bond_less_if_not_candidate() {

2016

1

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

2017

1

		assert_noop!(

2018

1

			ParachainStaking::schedule_candidate_bond_less(RuntimeOrigin::signed(6), 50),

2019

1

			Error::<Test>::CandidateDNE

2020

);

2021

1

});

2022

1

2023

2024

#[test]

2025

1

fn cannot_schedule_candidate_bond_less_if_new_total_below_min_candidate_stk() {

2026

1

	ExtBuilder::default()

2027

1

		.with_balances(vec![(1, 30)])

2028

1

		.with_candidates(vec![(1, 30)])

2029

1

		.build()

2030

1

		.execute_with(|| {

2031

1

			assert_noop!(

2032

1

				ParachainStaking::schedule_candidate_bond_less(RuntimeOrigin::signed(1), 21),

2033

1

				Error::<Test>::CandidateBondBelowMin

2034

);

2035

1

});

2036

1

2037

2038

#[test]

2039

1

fn can_schedule_candidate_bond_less_if_leaving_candidates() {

2040

1

	ExtBuilder::default()

2041

1

		.with_balances(vec![(1, 30)])

2042

1

		.with_candidates(vec![(1, 30)])

2043

1

		.build()

2044

1

		.execute_with(|| {

2045

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

2046

1

				RuntimeOrigin::signed(1),

2047

2048

));

2049

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2050

1

				RuntimeOrigin::signed(1),

2051

2052

));

2053

1

});

2054

1

2055

2056

#[test]

2057

1

fn cannot_schedule_candidate_bond_less_if_exited_candidates() {

2058

1

	ExtBuilder::default()

2059

1

		.with_balances(vec![(1, 30)])

2060

1

		.with_candidates(vec![(1, 30)])

2061

1

		.build()

2062

1

		.execute_with(|| {

2063

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

2064

1

				RuntimeOrigin::signed(1),

2065

2066

));

2067

1

			roll_to(10);

2068

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

2069

1

				RuntimeOrigin::signed(1),

2070

1,

2071

2072

));

2073

1

			assert_noop!(

2074

1

				ParachainStaking::schedule_candidate_bond_less(RuntimeOrigin::signed(1), 10),

2075

1

				Error::<Test>::CandidateDNE

2076

);

2077

1

});

2078

1

2079

2080

// 2. EXECUTE BOND LESS REQUEST

2081

2082

#[test]

2083

1

fn execute_candidate_bond_less_emits_correct_event() {

2084

1

	ExtBuilder::default()

2085

1

		.with_balances(vec![(1, 50)])

2086

1

		.with_candidates(vec![(1, 50)])

2087

1

		.build()

2088

1

		.execute_with(|| {

2089

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2090

1

				RuntimeOrigin::signed(1),

2091

2092

));

2093

1

			roll_to(10);

2094

1

			roll_blocks(1);

2095

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2096

1

				RuntimeOrigin::signed(1),

2097

2098

));

2099

1

			assert_events_eq!(Event::CandidateBondedLess {

2100

1

				candidate: 1,

2101

1

				amount: 30,

2102

1

				new_bond: 20

2103

1

});

2104

1

});

2105

1

2106

2107

#[test]

2108

1

fn execute_candidate_bond_less_unreserves_balance() {

2109

1

	ExtBuilder::default()

2110

1

		.with_balances(vec![(1, 30)])

2111

1

		.with_candidates(vec![(1, 30)])

2112

1

		.build()

2113

1

		.execute_with(|| {

2114

1

			assert_eq!(ParachainStaking::get_collator_stakable_free_balance(&1), 0);

2115

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2116

1

				RuntimeOrigin::signed(1),

2117

2118

));

2119

1

			roll_to(10);

2120

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2121

1

				RuntimeOrigin::signed(1),

2122

2123

));

2124

1

			assert_eq!(ParachainStaking::get_collator_stakable_free_balance(&1), 10);

2125

1

});

2126

1

2127

2128

#[test]

2129

1

fn execute_candidate_bond_less_decreases_total() {

2130

1

	ExtBuilder::default()

2131

1

		.with_balances(vec![(1, 30)])

2132

1

		.with_candidates(vec![(1, 30)])

2133

1

		.build()

2134

1

		.execute_with(|| {

2135

1

			let mut total = ParachainStaking::total();

2136

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2137

1

				RuntimeOrigin::signed(1),

2138

2139

));

2140

1

			roll_to(10);

2141

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2142

1

				RuntimeOrigin::signed(1),

2143

2144

));

2145

1

			total -= 10;

2146

1

			assert_eq!(ParachainStaking::total(), total);

2147

1

});

2148

1

2149

2150

#[test]

2151

1

fn execute_candidate_bond_less_updates_candidate_state() {

2152

1

	ExtBuilder::default()

2153

1

		.with_balances(vec![(1, 30)])

2154

1

		.with_candidates(vec![(1, 30)])

2155

1

		.build()

2156

1

		.execute_with(|| {

2157

1

			let candidate_state = ParachainStaking::candidate_info(1).expect("updated => exists");

2158

1

			assert_eq!(candidate_state.bond, 30);

2159

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2160

1

				RuntimeOrigin::signed(1),

2161

2162

));

2163

1

			roll_to(10);

2164

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2165

1

				RuntimeOrigin::signed(1),

2166

2167

));

2168

1

			let candidate_state = ParachainStaking::candidate_info(1).expect("updated => exists");

2169

1

			assert_eq!(candidate_state.bond, 20);

2170

1

});

2171

1

2172

2173

#[test]

2174

1

fn execute_candidate_bond_less_updates_candidate_pool() {

2175

1

	ExtBuilder::default()

2176

1

		.with_balances(vec![(1, 30)])

2177

1

		.with_candidates(vec![(1, 30)])

2178

1

		.build()

2179

1

		.execute_with(|| {

2180

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].owner, 1);

2181

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].amount, 30);

2182

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2183

1

				RuntimeOrigin::signed(1),

2184

2185

));

2186

1

			roll_to(10);

2187

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2188

1

				RuntimeOrigin::signed(1),

2189

2190

));

2191

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].owner, 1);

2192

1

			assert_eq!(ParachainStaking::candidate_pool().0[0].amount, 20);

2193

1

});

2194

1

2195

2196

// CANCEL CANDIDATE BOND LESS REQUEST

2197

2198

#[test]

2199

1

fn cancel_candidate_bond_less_emits_event() {

2200

1

	ExtBuilder::default()

2201

1

		.with_balances(vec![(1, 30)])

2202

1

		.with_candidates(vec![(1, 30)])

2203

1

		.build()

2204

1

		.execute_with(|| {

2205

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2206

1

				RuntimeOrigin::signed(1),

2207

2208

));

2209

1

			assert_ok!(ParachainStaking::cancel_candidate_bond_less(

2210

1

				RuntimeOrigin::signed(1)

2211

));

2212

1

			assert_events_emitted!(Event::CancelledCandidateBondLess {

2213

1

				candidate: 1,

2214

1

				amount: 10,

2215

1

				execute_round: 3,

2216

1

});

2217

1

});

2218

1

2219

2220

#[test]

2221

1

fn cancel_candidate_bond_less_updates_candidate_state() {

2222

1

	ExtBuilder::default()

2223

1

		.with_balances(vec![(1, 30)])

2224

1

		.with_candidates(vec![(1, 30)])

2225

1

		.build()

2226

1

		.execute_with(|| {

2227

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2228

1

				RuntimeOrigin::signed(1),

2229

2230

));

2231

1

			assert_ok!(ParachainStaking::cancel_candidate_bond_less(

2232

1

				RuntimeOrigin::signed(1)

2233

));

2234

1

			assert!(ParachainStaking::candidate_info(&1)

2235

1

				.unwrap()

2236

1

				.request

2237

1

				.is_none());

2238

1

});

2239

1

2240

2241

#[test]

2242

1

fn only_candidate_can_cancel_candidate_bond_less_request() {

2243

1

	ExtBuilder::default()

2244

1

		.with_balances(vec![(1, 30)])

2245

1

		.with_candidates(vec![(1, 30)])

2246

1

		.build()

2247

1

		.execute_with(|| {

2248

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2249

1

				RuntimeOrigin::signed(1),

2250

2251

));

2252

1

			assert_noop!(

2253

1

				ParachainStaking::cancel_candidate_bond_less(RuntimeOrigin::signed(2)),

2254

1

				Error::<Test>::CandidateDNE

2255

);

2256

1

});

2257

1

2258

2259

// DELEGATE

2260

2261

#[test]

2262

1

fn delegate_event_emits_correctly() {

2263

1

	ExtBuilder::default()

2264

1

		.with_balances(vec![(1, 30), (2, 10)])

2265

1

		.with_candidates(vec![(1, 30)])

2266

1

		.build()

2267

1

		.execute_with(|| {

2268

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2269

1

				RuntimeOrigin::signed(2),

2270

1,

2271

10,

2272

1

				Percent::zero(),

2273

0,

2274

0,

2275

2276

));

2277

1

			assert_events_eq!(Event::Delegation {

2278

1

				delegator: 2,

2279

1

				locked_amount: 10,

2280

1

				candidate: 1,

2281

1

				delegator_position: DelegatorAdded::AddedToTop { new_total: 40 },

2282

1

				auto_compound: Percent::zero(),

2283

1

});

2284

1

});

2285

1

2286

2287

#[test]

2288

1

fn delegate_reserves_balance() {

2289

1

	ExtBuilder::default()

2290

1

		.with_balances(vec![(1, 30), (2, 10)])

2291

1

		.with_candidates(vec![(1, 30)])

2292

1

		.build()

2293

1

		.execute_with(|| {

2294

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 10);

2295

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2296

1

				RuntimeOrigin::signed(2),

2297

1,

2298

10,

2299

1

				Percent::zero(),

2300

0,

2301

0,

2302

2303

));

2304

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 0);

2305

1

});

2306

1

2307

2308

#[test]

2309

1

fn delegate_updates_delegator_state() {

2310

1

	ExtBuilder::default()

2311

1

		.with_balances(vec![(1, 30), (2, 10)])

2312

1

		.with_candidates(vec![(1, 30)])

2313

1

		.build()

2314

1

		.execute_with(|| {

2315

1

			assert!(ParachainStaking::delegator_state(2).is_none());

2316

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2317

1

				RuntimeOrigin::signed(2),

2318

1,

2319

10,

2320

1

				Percent::zero(),

2321

0,

2322

0,

2323

2324

));

2325

1

			let delegator_state =

2326

1

				ParachainStaking::delegator_state(2).expect("just delegated => exists");

2327

1

			assert_eq!(delegator_state.total(), 10);

2328

1

			assert_eq!(delegator_state.delegations.0[0].owner, 1);

2329

1

			assert_eq!(delegator_state.delegations.0[0].amount, 10);

2330

1

});

2331

1

2332

2333

#[test]

2334

1

fn delegate_updates_collator_state() {

2335

1

	ExtBuilder::default()

2336

1

		.with_balances(vec![(1, 30), (2, 10)])

2337

1

		.with_candidates(vec![(1, 30)])

2338

1

		.build()

2339

1

		.execute_with(|| {

2340

1

			let candidate_state =

2341

1

				ParachainStaking::candidate_info(1).expect("registered in genesis");

2342

1

			assert_eq!(candidate_state.total_counted, 30);

2343

1

			let top_delegations =

2344

1

				ParachainStaking::top_delegations(1).expect("registered in genesis");

2345

1

			assert!(top_delegations.delegations.is_empty());

2346

1

			assert!(top_delegations.total.is_zero());

2347

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2348

1

				RuntimeOrigin::signed(2),

2349

1,

2350

10,

2351

1

				Percent::zero(),

2352

0,

2353

0,

2354

2355

));

2356

1

			let candidate_state =

2357

1

				ParachainStaking::candidate_info(1).expect("just delegated => exists");

2358

1

			assert_eq!(candidate_state.total_counted, 40);

2359

1

			let top_delegations =

2360

1

				ParachainStaking::top_delegations(1).expect("just delegated => exists");

2361

1

			assert_eq!(top_delegations.delegations[0].owner, 2);

2362

1

			assert_eq!(top_delegations.delegations[0].amount, 10);

2363

1

			assert_eq!(top_delegations.total, 10);

2364

1

});

2365

1

2366

2367

#[test]

2368

1

fn can_delegate_immediately_after_other_join_candidates() {

2369

1

	ExtBuilder::default()

2370

1

		.with_balances(vec![(1, 20), (2, 20)])

2371

1

		.build()

2372

1

		.execute_with(|| {

2373

1

			assert_ok!(ParachainStaking::join_candidates(

2374

1

				RuntimeOrigin::signed(1),

2375

20,

2376

2377

));

2378

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2379

1

				RuntimeOrigin::signed(2),

2380

1,

2381

20,

2382

1

				Percent::zero(),

2383

0,

2384

0,

2385

2386

));

2387

1

});

2388

1

2389

2390

#[test]

2391

1

fn can_delegate_if_revoking() {

2392

1

	ExtBuilder::default()

2393

1

		.with_balances(vec![(1, 20), (2, 30), (3, 20), (4, 20)])

2394

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20)])

2395

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

2396

1

		.build()

2397

1

		.execute_with(|| {

2398

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2399

1

				RuntimeOrigin::signed(2),

2400

2401

));

2402

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2403

1

				RuntimeOrigin::signed(2),

2404

4,

2405

10,

2406

1

				Percent::zero(),

2407

0,

2408

0,

2409

2410

));

2411

1

});

2412

1

2413

2414

#[test]

2415

1

fn cannot_delegate_if_full_and_new_delegation_less_than_or_equal_lowest_bottom() {

2416

1

	ExtBuilder::default()

2417

1

		.with_balances(vec![

2418

1

			(1, 20),

2419

1

			(2, 10),

2420

1

			(3, 10),

2421

1

			(4, 10),

2422

1

			(5, 10),

2423

1

			(6, 10),

2424

1

			(7, 10),

2425

1

			(8, 10),

2426

1

			(9, 10),

2427

1

			(10, 10),

2428

1

			(11, 10),

2429

1

])

2430

1

		.with_candidates(vec![(1, 20)])

2431

1

		.with_delegations(vec![

2432

1

			(2, 1, 10),

2433

1

			(3, 1, 10),

2434

1

			(4, 1, 10),

2435

1

			(5, 1, 10),

2436

1

			(6, 1, 10),

2437

1

			(8, 1, 10),

2438

1

			(9, 1, 10),

2439

1

			(10, 1, 10),

2440

1

])

2441

1

		.build()

2442

1

		.execute_with(|| {

2443

1

			assert_noop!(

2444

1

				ParachainStaking::delegate_with_auto_compound(

2445

1

					RuntimeOrigin::signed(11),

2446

1,

2447

10,

2448

1

					Percent::zero(),

2449

8,

2450

0,

2451

2452

),

2453

1

				Error::<Test>::CannotDelegateLessThanOrEqualToLowestBottomWhenFull

2454

);

2455

1

});

2456

1

2457

2458

#[test]

2459

1

fn can_delegate_if_full_and_new_delegation_greater_than_lowest_bottom() {

2460

1

	ExtBuilder::default()

2461

1

		.with_balances(vec![

2462

1

			(1, 20),

2463

1

			(2, 10),

2464

1

			(3, 10),

2465

1

			(4, 10),

2466

1

			(5, 10),

2467

1

			(6, 10),

2468

1

			(7, 10),

2469

1

			(8, 10),

2470

1

			(9, 10),

2471

1

			(10, 10),

2472

1

			(11, 11),

2473

1

])

2474

1

		.with_candidates(vec![(1, 20)])

2475

1

		.with_delegations(vec![

2476

1

			(2, 1, 10),

2477

1

			(3, 1, 10),

2478

1

			(4, 1, 10),

2479

1

			(5, 1, 10),

2480

1

			(6, 1, 10),

2481

1

			(8, 1, 10),

2482

1

			(9, 1, 10),

2483

1

			(10, 1, 10),

2484

1

])

2485

1

		.build()

2486

1

		.execute_with(|| {

2487

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2488

1

				RuntimeOrigin::signed(11),

2489

1,

2490

11,

2491

1

				Percent::zero(),

2492

8,

2493

0,

2494

2495

));

2496

1

			assert_events_emitted!(Event::DelegationKicked {

2497

1

				delegator: 10,

2498

1

				candidate: 1,

2499

1

				unstaked_amount: 10

2500

1

});

2501

1

			assert_events_emitted!(Event::DelegatorLeft {

2502

1

				delegator: 10,

2503

1

				unstaked_amount: 10

2504

1

});

2505

1

});

2506

1

2507

2508

#[test]

2509

1

fn can_still_delegate_if_leaving() {

2510

1

	ExtBuilder::default()

2511

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20)])

2512

1

		.with_candidates(vec![(1, 20), (3, 20)])

2513

1

		.with_delegations(vec![(2, 1, 10)])

2514

1

		.build()

2515

1

		.execute_with(|| {

2516

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2517

1

				RuntimeOrigin::signed(2),

2518

1,

2519

));

2520

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2521

1

				RuntimeOrigin::signed(2),

2522

3,

2523

10,

2524

1

				Percent::zero(),

2525

0,

2526

0,

2527

2528

));

2529

1

});

2530

1

2531

2532

#[test]

2533

1

fn cannot_delegate_if_candidate() {

2534

1

	ExtBuilder::default()

2535

1

		.with_balances(vec![(1, 20), (2, 30)])

2536

1

		.with_candidates(vec![(1, 20), (2, 20)])

2537

1

		.build()

2538

1

		.execute_with(|| {

2539

1

			assert_noop!(

2540

1

				ParachainStaking::delegate_with_auto_compound(

2541

1

					RuntimeOrigin::signed(2),

2542

1,

2543

10,

2544

1

					Percent::zero(),

2545

0,

2546

0,

2547

2548

),

2549

1

				Error::<Test>::CandidateExists

2550

);

2551

1

});

2552

1

2553

2554

#[test]

2555

1

fn cannot_delegate_if_already_delegated() {

2556

1

	ExtBuilder::default()

2557

1

		.with_balances(vec![(1, 20), (2, 30)])

2558

1

		.with_candidates(vec![(1, 20)])

2559

1

		.with_delegations(vec![(2, 1, 20)])

2560

1

		.build()

2561

1

		.execute_with(|| {

2562

1

			assert_noop!(

2563

1

				ParachainStaking::delegate_with_auto_compound(

2564

1

					RuntimeOrigin::signed(2),

2565

1,

2566

10,

2567

1

					Percent::zero(),

2568

1,

2569

0,

2570

2571

),

2572

1

				Error::<Test>::AlreadyDelegatedCandidate

2573

);

2574

1

});

2575

1

2576

2577

#[test]

2578

1

fn cannot_delegate_more_than_max_delegations() {

2579

1

	ExtBuilder::default()

2580

1

		.with_balances(vec![(1, 20), (2, 50), (3, 20), (4, 20), (5, 20), (6, 20)])

2581

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20), (5, 20), (6, 20)])

2582

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10), (2, 4, 10), (2, 5, 10)])

2583

1

		.build()

2584

1

		.execute_with(|| {

2585

1

			assert_noop!(

2586

1

				ParachainStaking::delegate_with_auto_compound(

2587

1

					RuntimeOrigin::signed(2),

2588

6,

2589

10,

2590

1

					Percent::zero(),

2591

0,

2592

0,

2593

4,

2594

),

2595

1

				Error::<Test>::ExceedMaxDelegationsPerDelegator,

2596

);

2597

1

});

2598

1

2599

2600

#[test]

2601

1

fn sufficient_delegate_weight_hint_succeeds() {

2602

1

	ExtBuilder::default()

2603

1

		.with_balances(vec![

2604

1

			(1, 20),

2605

1

			(2, 20),

2606

1

			(3, 20),

2607

1

			(4, 20),

2608

1

			(5, 20),

2609

1

			(6, 20),

2610

1

			(7, 20),

2611

1

			(8, 20),

2612

1

			(9, 20),

2613

1

			(10, 20),

2614

1

])

2615

1

		.with_candidates(vec![(1, 20), (2, 20)])

2616

1

		.with_delegations(vec![(3, 1, 10), (4, 1, 10), (5, 1, 10), (6, 1, 10)])

2617

1

		.build()

2618

1

		.execute_with(|| {

2619

1

			let mut count = 4u32;

2620

5

			for i in 7..11 {

2621

4

				assert_ok!(ParachainStaking::delegate_with_auto_compound(

2622

4

					RuntimeOrigin::signed(i),

2623

1,

2624

10,

2625

4

					Percent::zero(),

2626

4

					count,

2627

0,

2628

2629

));

2630

4

				count += 1u32;

2631

2632

1

			let mut count = 0u32;

2633

9

			for i in 3..11 {

2634

8

				assert_ok!(ParachainStaking::delegate_with_auto_compound(

2635

8

					RuntimeOrigin::signed(i),

2636

2,

2637

10,

2638

8

					Percent::zero(),

2639

8

					count,

2640

0,

2641

					1u32

2642

));

2643

8

				count += 1u32;

2644

2645

1

});

2646

1

2647

2648

#[test]

2649

1

fn insufficient_delegate_weight_hint_fails() {

2650

1

	ExtBuilder::default()

2651

1

		.with_balances(vec![

2652

1

			(1, 20),

2653

1

			(2, 20),

2654

1

			(3, 20),

2655

1

			(4, 20),

2656

1

			(5, 20),

2657

1

			(6, 20),

2658

1

			(7, 20),

2659

1

			(8, 20),

2660

1

			(9, 20),

2661

1

			(10, 20),

2662

1

])

2663

1

		.with_candidates(vec![(1, 20), (2, 20)])

2664

1

		.with_delegations(vec![(3, 1, 10), (4, 1, 10), (5, 1, 10), (6, 1, 10)])

2665

1

		.build()

2666

1

		.execute_with(|| {

2667

1

			let mut count = 3u32;

2668

5

			for i in 7..11 {

2669

4

				assert_noop!(

2670

4

					ParachainStaking::delegate_with_auto_compound(

2671

4

						RuntimeOrigin::signed(i),

2672

1,

2673

10,

2674

4

						Percent::zero(),

2675

4

						count,

2676

0,

2677

2678

),

2679

4

					Error::<Test>::TooLowCandidateDelegationCountToDelegate

2680

);

2681

2682

			// to set up for next error test

2683

1

			count = 4u32;

2684

5

			for i in 7..11 {

2685

4

				assert_ok!(ParachainStaking::delegate_with_auto_compound(

2686

4

					RuntimeOrigin::signed(i),

2687

1,

2688

10,

2689

4

					Percent::zero(),

2690

4

					count,

2691

0,

2692

2693

));

2694

4

				count += 1u32;

2695

2696

1

			count = 0u32;

2697

9

			for i in 3..11 {

2698

8

				assert_noop!(

2699

8

					ParachainStaking::delegate_with_auto_compound(

2700

8

						RuntimeOrigin::signed(i),

2701

2,

2702

10,

2703

8

						Percent::zero(),

2704

8

						count,

2705

0,

2706

2707

),

2708

8

					Error::<Test>::TooLowDelegationCountToDelegate

2709

);

2710

8

				count += 1u32;

2711

2712

1

});

2713

1

2714

2715

// SCHEDULE REVOKE DELEGATION

2716

2717

#[test]

2718

1

fn revoke_delegation_event_emits_correctly() {

2719

1

	ExtBuilder::default()

2720

1

		.with_balances(vec![(1, 30), (2, 20), (3, 30)])

2721

1

		.with_candidates(vec![(1, 30), (3, 30)])

2722

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

2723

1

		.build()

2724

1

		.execute_with(|| {

2725

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2726

1

				RuntimeOrigin::signed(2),

2727

2728

));

2729

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

2730

1

				round: 1,

2731

1

				delegator: 2,

2732

1

				candidate: 1,

2733

1

				scheduled_exit: 3,

2734

1

});

2735

1

			roll_to_round_begin(3);

2736

1

			roll_blocks(1);

2737

1

			assert_ok!(ParachainStaking::execute_delegation_request(

2738

1

				RuntimeOrigin::signed(2),

2739

2,

2740

2741

));

2742

1

			assert_events_eq!(

2743

1

				Event::DelegatorLeftCandidate {

2744

1

					delegator: 2,

2745

1

					candidate: 1,

2746

1

					unstaked_amount: 10,

2747

1

					total_candidate_staked: 30

2748

1

},

2749

1

				Event::DelegationRevoked {

2750

1

					delegator: 2,

2751

1

					candidate: 1,

2752

1

					unstaked_amount: 10,

2753

1

},

2754

);

2755

1

});

2756

1

2757

2758

#[test]

2759

1

fn can_revoke_delegation_if_revoking_another_delegation() {

2760

1

	ExtBuilder::default()

2761

1

		.with_balances(vec![(1, 30), (2, 20), (3, 20)])

2762

1

		.with_candidates(vec![(1, 30), (3, 20)])

2763

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

2764

1

		.build()

2765

1

		.execute_with(|| {

2766

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2767

1

				RuntimeOrigin::signed(2),

2768

2769

));

2770

			// this is an exit implicitly because last delegation revoked

2771

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2772

1

				RuntimeOrigin::signed(2),

2773

2774

));

2775

1

});

2776

1

2777

2778

#[test]

2779

1

fn cannot_revoke_delegation_if_not_delegator() {

2780

1

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

2781

1

		assert_noop!(

2782

1

			ParachainStaking::schedule_revoke_delegation(RuntimeOrigin::signed(2), 1),

2783

1

			Error::<Test>::DelegatorDNE

2784

);

2785

1

});

2786

1

2787

2788

#[test]

2789

1

fn cannot_revoke_delegation_that_dne() {

2790

1

	ExtBuilder::default()

2791

1

		.with_balances(vec![(1, 30), (2, 10)])

2792

1

		.with_candidates(vec![(1, 30)])

2793

1

		.with_delegations(vec![(2, 1, 10)])

2794

1

		.build()

2795

1

		.execute_with(|| {

2796

1

			assert_noop!(

2797

1

				ParachainStaking::schedule_revoke_delegation(RuntimeOrigin::signed(2), 3),

2798

1

				Error::<Test>::DelegationDNE

2799

);

2800

1

});

2801

1

2802

2803

#[test]

2804

1

fn can_schedule_revoke_delegation_below_min_delegator_stake() {

2805

1

	ExtBuilder::default()

2806

1

		.with_balances(vec![(1, 20), (2, 8), (3, 20)])

2807

1

		.with_candidates(vec![(1, 20), (3, 20)])

2808

1

		.with_delegations(vec![(2, 1, 5), (2, 3, 3)])

2809

1

		.build()

2810

1

		.execute_with(|| {

2811

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2812

1

				RuntimeOrigin::signed(2),

2813

2814

));

2815

1

});

2816

1

2817

2818

// DELEGATOR BOND MORE

2819

2820

#[test]

2821

1

fn delegator_bond_more_reserves_balance() {

2822

1

	ExtBuilder::default()

2823

1

		.with_balances(vec![(1, 30), (2, 15)])

2824

1

		.with_candidates(vec![(1, 30)])

2825

1

		.with_delegations(vec![(2, 1, 10)])

2826

1

		.build()

2827

1

		.execute_with(|| {

2828

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 5);

2829

1

			assert_ok!(ParachainStaking::delegator_bond_more(

2830

1

				RuntimeOrigin::signed(2),

2831

1,

2832

2833

));

2834

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 0);

2835

1

});

2836

1

2837

2838

#[test]

2839

1

fn delegator_bond_more_increases_total_staked() {

2840

1

	ExtBuilder::default()

2841

1

		.with_balances(vec![(1, 30), (2, 15)])

2842

1

		.with_candidates(vec![(1, 30)])

2843

1

		.with_delegations(vec![(2, 1, 10)])

2844

1

		.build()

2845

1

		.execute_with(|| {

2846

1

			assert_eq!(ParachainStaking::total(), 40);

2847

1

			assert_ok!(ParachainStaking::delegator_bond_more(

2848

1

				RuntimeOrigin::signed(2),

2849

1,

2850

2851

));

2852

1

			assert_eq!(ParachainStaking::total(), 45);

2853

1

});

2854

1

2855

2856

#[test]

2857

1

fn delegator_bond_more_updates_delegator_state() {

2858

1

	ExtBuilder::default()

2859

1

		.with_balances(vec![(1, 30), (2, 15)])

2860

1

		.with_candidates(vec![(1, 30)])

2861

1

		.with_delegations(vec![(2, 1, 10)])

2862

1

		.build()

2863

1

		.execute_with(|| {

2864

1

			assert_eq!(

2865

1

				ParachainStaking::delegator_state(2)

2866

1

					.expect("exists")

2867

1

					.total(),

2868

2869

);

2870

1

			assert_ok!(ParachainStaking::delegator_bond_more(

2871

1

				RuntimeOrigin::signed(2),

2872

1,

2873

2874

));

2875

1

			assert_eq!(

2876

1

				ParachainStaking::delegator_state(2)

2877

1

					.expect("exists")

2878

1

					.total(),

2879

2880

);

2881

1

});

2882

1

2883

2884

#[test]

2885

1

fn delegator_bond_more_updates_candidate_state_top_delegations() {

2886

1

	ExtBuilder::default()

2887

1

		.with_balances(vec![(1, 30), (2, 15)])

2888

1

		.with_candidates(vec![(1, 30)])

2889

1

		.with_delegations(vec![(2, 1, 10)])

2890

1

		.build()

2891

1

		.execute_with(|| {

2892

1

			assert_eq!(

2893

1

				ParachainStaking::top_delegations(1).unwrap().delegations[0].owner,

2894

2895

);

2896

1

			assert_eq!(

2897

1

				ParachainStaking::top_delegations(1).unwrap().delegations[0].amount,

2898

2899

);

2900

1

			assert_eq!(ParachainStaking::top_delegations(1).unwrap().total, 10);

2901

1

			assert_ok!(ParachainStaking::delegator_bond_more(

2902

1

				RuntimeOrigin::signed(2),

2903

1,

2904

2905

));

2906

1

			assert_eq!(

2907

1

				ParachainStaking::top_delegations(1).unwrap().delegations[0].owner,

2908

2909

);

2910

1

			assert_eq!(

2911

1

				ParachainStaking::top_delegations(1).unwrap().delegations[0].amount,

2912

2913

);

2914

1

			assert_eq!(ParachainStaking::top_delegations(1).unwrap().total, 15);

2915

1

});

2916

1

2917

2918

#[test]

2919

1

fn delegator_bond_more_updates_candidate_state_bottom_delegations() {

2920

1

	ExtBuilder::default()

2921

1

		.with_balances(vec![(1, 30), (2, 20), (3, 20), (4, 20), (5, 20), (6, 20)])

2922

1

		.with_candidates(vec![(1, 30)])

2923

1

		.with_delegations(vec![

2924

1

			(2, 1, 10),

2925

1

			(3, 1, 20),

2926

1

			(4, 1, 20),

2927

1

			(5, 1, 20),

2928

1

			(6, 1, 20),

2929

1

])

2930

1

		.build()

2931

1

		.execute_with(|| {

2932

1

			assert_eq!(

2933

1

				ParachainStaking::bottom_delegations(1)

2934

1

					.expect("exists")

2935

1

					.delegations[0]

2936

					.owner,

2937

2938

);

2939

1

			assert_eq!(

2940

1

				ParachainStaking::bottom_delegations(1)

2941

1

					.expect("exists")

2942

1

					.delegations[0]

2943

					.amount,

2944

2945

);

2946

1

			assert_eq!(ParachainStaking::bottom_delegations(1).unwrap().total, 10);

2947

1

			assert_ok!(ParachainStaking::delegator_bond_more(

2948

1

				RuntimeOrigin::signed(2),

2949

1,

2950

2951

));

2952

1

			assert_events_eq!(Event::DelegationIncreased {

2953

1

				delegator: 2,

2954

1

				candidate: 1,

2955

1

				amount: 5,

2956

1

				in_top: false

2957

1

});

2958

1

			assert_eq!(

2959

1

				ParachainStaking::bottom_delegations(1)

2960

1

					.expect("exists")

2961

1

					.delegations[0]

2962

					.owner,

2963

2964

);

2965

1

			assert_eq!(

2966

1

				ParachainStaking::bottom_delegations(1)

2967

1

					.expect("exists")

2968

1

					.delegations[0]

2969

					.amount,

2970

2971

);

2972

1

			assert_eq!(ParachainStaking::bottom_delegations(1).unwrap().total, 15);

2973

1

});

2974

1

2975

2976

#[test]

2977

1

fn delegator_bond_more_increases_total() {

2978

1

	ExtBuilder::default()

2979

1

		.with_balances(vec![(1, 30), (2, 15)])

2980

1

		.with_candidates(vec![(1, 30)])

2981

1

		.with_delegations(vec![(2, 1, 10)])

2982

1

		.build()

2983

1

		.execute_with(|| {

2984

1

			assert_eq!(ParachainStaking::total(), 40);

2985

1

			assert_ok!(ParachainStaking::delegator_bond_more(

2986

1

				RuntimeOrigin::signed(2),

2987

1,

2988

2989

));

2990

1

			assert_eq!(ParachainStaking::total(), 45);

2991

1

});

2992

1

2993

2994

#[test]

2995

1

fn can_delegator_bond_more_for_leaving_candidate() {

2996

1

	ExtBuilder::default()

2997

1

		.with_balances(vec![(1, 30), (2, 15)])

2998

1

		.with_candidates(vec![(1, 30)])

2999

1

		.with_delegations(vec![(2, 1, 10)])

3000

1

		.build()

3001

1

		.execute_with(|| {

3002

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

3003

1

				RuntimeOrigin::signed(1),

3004

3005

));

3006

1

			assert_ok!(ParachainStaking::delegator_bond_more(

3007

1

				RuntimeOrigin::signed(2),

3008

1,

3009

3010

));

3011

1

});

3012

1

3013

3014

#[test]

3015

1

fn delegator_bond_more_disallowed_when_revoke_scheduled() {

3016

1

	ExtBuilder::default()

3017

1

		.with_balances(vec![(1, 30), (2, 25)])

3018

1

		.with_candidates(vec![(1, 30)])

3019

1

		.with_delegations(vec![(2, 1, 10)])

3020

1

		.build()

3021

1

		.execute_with(|| {

3022

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3023

1

				RuntimeOrigin::signed(2),

3024

3025

));

3026

1

			assert_noop!(

3027

1

				ParachainStaking::delegator_bond_more(RuntimeOrigin::signed(2), 1, 5),

3028

1

				<Error<Test>>::PendingDelegationRevoke

3029

);

3030

1

});

3031

1

3032

3033

#[test]

3034

1

fn delegator_bond_more_allowed_when_bond_decrease_scheduled() {

3035

1

	ExtBuilder::default()

3036

1

		.with_balances(vec![(1, 30), (2, 25)])

3037

1

		.with_candidates(vec![(1, 30)])

3038

1

		.with_delegations(vec![(2, 1, 15)])

3039

1

		.build()

3040

1

		.execute_with(|| {

3041

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3042

1

				RuntimeOrigin::signed(2),

3043

1,

3044

5,

3045

));

3046

1

			assert_ok!(ParachainStaking::delegator_bond_more(

3047

1

				RuntimeOrigin::signed(2),

3048

1,

3049

3050

));

3051

1

});

3052

1

3053

3054

// DELEGATOR BOND LESS

3055

3056

#[test]

3057

1

fn delegator_bond_less_event_emits_correctly() {

3058

1

	ExtBuilder::default()

3059

1

		.with_balances(vec![(1, 30), (2, 10)])

3060

1

		.with_candidates(vec![(1, 30)])

3061

1

		.with_delegations(vec![(2, 1, 10)])

3062

1

		.build()

3063

1

		.execute_with(|| {

3064

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3065

1

				RuntimeOrigin::signed(2),

3066

1,

3067

3068

));

3069

1

			assert_events_eq!(Event::DelegationDecreaseScheduled {

3070

1

				delegator: 2,

3071

1

				candidate: 1,

3072

1

				amount_to_decrease: 5,

3073

1

				execute_round: 3,

3074

1

});

3075

1

});

3076

1

3077

3078

#[test]

3079

1

fn delegator_bond_less_updates_delegator_state() {

3080

1

	ExtBuilder::default()

3081

1

		.with_balances(vec![(1, 30), (2, 10)])

3082

1

		.with_candidates(vec![(1, 30)])

3083

1

		.with_delegations(vec![(2, 1, 10)])

3084

1

		.build()

3085

1

		.execute_with(|| {

3086

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3087

1

				RuntimeOrigin::signed(2),

3088

1,

3089

3090

));

3091

1

			let state = ParachainStaking::delegation_scheduled_requests(&1, &2);

3092

1

			assert_eq!(

3093

				state,

3094

1

				vec![ScheduledRequest {

3095

1

					when_executable: 3,

3096

1

					action: DelegationAction::Decrease(5),

3097

1

}],

3098

);

3099

1

});

3100

1

3101

3102

#[test]

3103

1

fn can_schedule_multiple_bond_less_requests_for_same_delegation() {

3104

1

	ExtBuilder::default()

3105

1

		.with_balances(vec![(1, 100), (2, 100)])

3106

1

		.with_candidates(vec![(1, 50)])

3107

1

		.with_delegations(vec![(2, 1, 30)])

3108

1

		.build()

3109

1

		.execute_with(|| {

3110

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3111

1

				RuntimeOrigin::signed(2),

3112

1,

3113

3114

));

3115

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3116

1

				RuntimeOrigin::signed(2),

3117

1,

3118

3119

));

3120

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3121

1

				RuntimeOrigin::signed(2),

3122

1,

3123

3124

));

3125

3126

1

			let requests = ParachainStaking::delegation_scheduled_requests(&1, &2);

3127

1

			assert_eq!(requests.len(), 3);

3128

1

			assert_eq!(requests[0].action, DelegationAction::Decrease(5));

3129

1

			assert_eq!(requests[1].action, DelegationAction::Decrease(5));

3130

1

			assert_eq!(requests[2].action, DelegationAction::Decrease(5));

3131

1

});

3132

1

3133

3134

#[test]

3135

1

fn execute_multiple_bond_less_requests_in_fifo_order() {

3136

1

	ExtBuilder::default()

3137

1

		.with_balances(vec![(1, 50), (2, 50)])

3138

1

		.with_candidates(vec![(1, 50)])

3139

1

		.with_delegations(vec![(2, 1, 20)])

3140

1

		.build()

3141

1

		.execute_with(|| {

3142

1

			assert_eq!(

3143

1

				ParachainStaking::delegator_state(2)

3144

1

					.expect("exists")

3145

1

					.total(),

3146

3147

);

3148

3149

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3150

1

				RuntimeOrigin::signed(2),

3151

1,

3152

3153

));

3154

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3155

1

				RuntimeOrigin::signed(2),

3156

1,

3157

3158

));

3159

3160

1

			let requests = ParachainStaking::delegation_scheduled_requests(&1, &2);

3161

1

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

3162

1

			assert_eq!(requests[0].action, DelegationAction::Decrease(5));

3163

1

			assert_eq!(requests[1].action, DelegationAction::Decrease(7));

3164

3165

1

			roll_to(10);

3166

3167

			// Execute first pending request

3168

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3169

1

				RuntimeOrigin::signed(2),

3170

2,

3171

3172

));

3173

1

			let state_after_first = ParachainStaking::delegator_state(2).expect("exists");

3174

1

			assert_eq!(state_after_first.total(), 15);

3175

3176

1

			let remaining_requests = ParachainStaking::delegation_scheduled_requests(&1, &2);

3177

1

			assert_eq!(remaining_requests.len(), 1);

3178

1

			assert_eq!(remaining_requests[0].action, DelegationAction::Decrease(7));

3179

3180

			// Execute second pending request

3181

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3182

1

				RuntimeOrigin::signed(2),

3183

2,

3184

3185

));

3186

1

			let state_after_second = ParachainStaking::delegator_state(2).expect("exists");

3187

1

			assert_eq!(state_after_second.total(), 8);

3188

3189

1

			let remaining_requests = ParachainStaking::delegation_scheduled_requests(&1, &2);

3190

1

			assert_eq!(remaining_requests.len(), 0);

3191

1

});

3192

1

3193

3194

#[test]

3195

1

fn cannot_revoke_delegation_if_other_request_pending() {

3196

1

	ExtBuilder::default()

3197

1

		.with_balances(vec![(1, 30), (2, 25), (3, 20)])

3198

1

		.with_candidates(vec![(1, 30), (3, 20)])

3199

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

3200

1

		.build()

3201

1

		.execute_with(|| {

3202

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3203

1

				RuntimeOrigin::signed(2),

3204

1,

3205

3206

));

3207

1

			assert_noop!(

3208

1

				ParachainStaking::schedule_revoke_delegation(RuntimeOrigin::signed(2), 1)

3209

1

					.map_err(|err| err.error),

3210

1

				Error::<Test>::PendingDelegationRequestAlreadyExists

3211

);

3212

1

});

3213

1

3214

3215

#[test]

3216

1

fn cannot_schedule_more_than_max_bond_less_requests_per_delegation() {

3217

1

	ExtBuilder::default()

3218

1

		.with_balances(vec![(1, 200), (2, 200)])

3219

1

		.with_candidates(vec![(1, 100)])

3220

1

		.with_delegations(vec![(2, 1, 80)])

3221

1

		.build()

3222

1

		.execute_with(|| {

3223

51

			for _ in 0..50 {

3224

50

				assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3225

50

					RuntimeOrigin::signed(2),

3226

1,

3227

3228

));

3229

3230

1

			assert_noop!(

3231

1

				ParachainStaking::schedule_delegator_bond_less(RuntimeOrigin::signed(2), 1, 1)

3232

1

					.map_err(|err| err.error),

3233

1

				Error::<Test>::ExceedMaxDelegationsPerDelegator

3234

);

3235

1

});

3236

1

3237

3238

#[test]

3239

1

fn cannot_exceed_max_delegators_with_pending_requests_per_collator() {

3240

	// Build a scenario with one collator and one real delegator,

3241

	// then artificially saturate the scheduled-requests map for that collator

3242

	// to the configured maximum number of delegators.

3243

1

	ExtBuilder::default()

3244

1

		.with_balances(vec![(1, 1_000), (2, 1_000)])

3245

1

		.with_candidates(vec![(1, 100)])

3246

1

		.with_delegations(vec![(2, 1, 10)])

3247

1

		.build()

3248

1

		.execute_with(|| {

3249

1

			let max_delegators_per_collator =

3250

1

				(<Test as crate::Config>::MaxTopDelegationsPerCandidate::get()

3251

1

					+ <Test as crate::Config>::MaxBottomDelegationsPerCandidate::get()) as u64;

3252

3253

			// Artificially create `max_delegators_per_collator` delegators with pending

3254

			// requests for collator 1 by directly populating storage.

3255

8

			for i in 0..max_delegators_per_collator {

3256

8

				let fake_delegator: AccountId = 1000 + i;

3257

8

				let requests = BoundedVec::try_from(vec![ScheduledRequest {

3258

8

					when_executable: 1,

3259

8

					action: DelegationAction::Decrease(1),

3260

8

}])

3261

8

				.expect("must succeed");

3262

8

				<DelegationScheduledRequests<Test>>::insert(1, fake_delegator, requests);

3263

8

3264

3265

			// Maintain the per-collator counter consistently with the synthetic setup.

3266

1

			<DelegationScheduledRequestsPerCollator<Test>>::insert(

3267

1,

3268

1

				max_delegators_per_collator as u32,

3269

);

3270

3271

			// Now the collator already has the maximum number of delegators with pending

3272

			// requests. Scheduling a new request for delegator 2 towards collator 1

3273

			// should fail with `ExceedMaxDelegationsPerDelegator`.

3274

1

			assert_noop!(

3275

1

				ParachainStaking::schedule_delegator_bond_less(RuntimeOrigin::signed(2), 1, 1)

3276

1

					.map_err(|err| err.error),

3277

1

				Error::<Test>::ExceedMaxDelegationsPerDelegator

3278

);

3279

1

});

3280

1

3281

3282

#[test]

3283

1

fn cannot_delegator_bond_less_if_revoking() {

3284

1

	ExtBuilder::default()

3285

1

		.with_balances(vec![(1, 30), (2, 25), (3, 20)])

3286

1

		.with_candidates(vec![(1, 30), (3, 20)])

3287

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

3288

1

		.build()

3289

1

		.execute_with(|| {

3290

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3291

1

				RuntimeOrigin::signed(2),

3292

3293

));

3294

1

			assert_noop!(

3295

1

				ParachainStaking::schedule_delegator_bond_less(RuntimeOrigin::signed(2), 1, 1)

3296

1

					.map_err(|err| err.error),

3297

1

				Error::<Test>::PendingDelegationRequestAlreadyExists

3298

);

3299

1

});

3300

1

3301

3302

#[test]

3303

1

fn cannot_delegator_bond_less_if_not_delegator() {

3304

1

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

3305

1

		assert_noop!(

3306

1

			ParachainStaking::schedule_delegator_bond_less(RuntimeOrigin::signed(2), 1, 5)

3307

1

				.map_err(|err| err.error),

3308

1

			Error::<Test>::DelegatorDNE

3309

);

3310

1

});

3311

1

3312

3313

#[test]

3314

1

fn cannot_delegator_bond_less_if_candidate_dne() {

3315

1

	ExtBuilder::default()

3316

1

		.with_balances(vec![(1, 30), (2, 10)])

3317

1

		.with_candidates(vec![(1, 30)])

3318

1

		.with_delegations(vec![(2, 1, 10)])

3319

1

		.build()

3320

1

		.execute_with(|| {

3321

1

			assert_noop!(

3322

1

				ParachainStaking::schedule_delegator_bond_less(RuntimeOrigin::signed(2), 3, 5)

3323

1

					.map_err(|err| err.error),

3324

1

				Error::<Test>::DelegationDNE

3325

);

3326

1

});

3327

1

3328

3329

#[test]

3330

1

fn cannot_delegator_bond_less_if_delegation_dne() {

3331

1

	ExtBuilder::default()

3332

1

		.with_balances(vec![(1, 30), (2, 10), (3, 30)])

3333

1

		.with_candidates(vec![(1, 30), (3, 30)])

3334

1

		.with_delegations(vec![(2, 1, 10)])

3335

1

		.build()

3336

1

		.execute_with(|| {

3337

1

			assert_noop!(

3338

1

				ParachainStaking::schedule_delegator_bond_less(RuntimeOrigin::signed(2), 3, 5)

3339

1

					.map_err(|err| err.error),

3340

1

				Error::<Test>::DelegationDNE

3341

);

3342

1

});

3343

1

3344

3345

#[test]

3346

1

fn cannot_delegator_bond_less_more_than_total_delegation() {

3347

1

	ExtBuilder::default()

3348

1

		.with_balances(vec![(1, 30), (2, 10)])

3349

1

		.with_candidates(vec![(1, 30)])

3350

1

		.with_delegations(vec![(2, 1, 10)])

3351

1

		.build()

3352

1

		.execute_with(|| {

3353

1

			assert_noop!(

3354

1

				ParachainStaking::schedule_delegator_bond_less(RuntimeOrigin::signed(2), 1, 11)

3355

1

					.map_err(|err| err.error),

3356

1

				Error::<Test>::DelegatorBondBelowMin

3357

);

3358

1

});

3359

1

3360

3361

#[test]

3362

1

fn cannot_delegator_bond_less_below_min_delegation() {

3363

1

	ExtBuilder::default()

3364

1

		.with_balances(vec![(1, 30), (2, 20), (3, 30)])

3365

1

		.with_candidates(vec![(1, 30), (3, 30)])

3366

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

3367

1

		.build()

3368

1

		.execute_with(|| {

3369

1

			assert_noop!(

3370

1

				ParachainStaking::schedule_delegator_bond_less(RuntimeOrigin::signed(2), 1, 8)

3371

1

					.map_err(|err| err.error),

3372

1

				Error::<Test>::DelegationBelowMin

3373

);

3374

1

});

3375

1

3376

3377

// EXECUTE PENDING DELEGATION REQUEST

3378

3379

// 1. REVOKE DELEGATION

3380

3381

#[test]

3382

1

fn execute_revoke_delegation_emits_exit_event_if_exit_happens() {

3383

	// last delegation is revocation

3384

1

	ExtBuilder::default()

3385

1

		.with_balances(vec![(1, 30), (2, 10)])

3386

1

		.with_candidates(vec![(1, 30)])

3387

1

		.with_delegations(vec![(2, 1, 10)])

3388

1

		.build()

3389

1

		.execute_with(|| {

3390

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3391

1

				RuntimeOrigin::signed(2),

3392

3393

));

3394

1

			roll_to(10);

3395

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3396

1

				RuntimeOrigin::signed(2),

3397

2,

3398

3399

));

3400

1

			assert_events_emitted!(Event::DelegatorLeftCandidate {

3401

1

				delegator: 2,

3402

1

				candidate: 1,

3403

1

				unstaked_amount: 10,

3404

1

				total_candidate_staked: 30

3405

1

});

3406

1

			assert_events_emitted!(Event::DelegatorLeft {

3407

1

				delegator: 2,

3408

1

				unstaked_amount: 10

3409

1

});

3410

1

});

3411

1

3412

3413

#[test]

3414

1

fn revoke_delegation_executes_exit_if_last_delegation() {

3415

	// last delegation is revocation

3416

1

	ExtBuilder::default()

3417

1

		.with_balances(vec![(1, 30), (2, 10)])

3418

1

		.with_candidates(vec![(1, 30)])

3419

1

		.with_delegations(vec![(2, 1, 10)])

3420

1

		.build()

3421

1

		.execute_with(|| {

3422

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3423

1

				RuntimeOrigin::signed(2),

3424

3425

));

3426

1

			roll_to(10);

3427

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3428

1

				RuntimeOrigin::signed(2),

3429

2,

3430

3431

));

3432

1

			assert_events_emitted!(Event::DelegatorLeftCandidate {

3433

1

				delegator: 2,

3434

1

				candidate: 1,

3435

1

				unstaked_amount: 10,

3436

1

				total_candidate_staked: 30

3437

1

});

3438

1

			assert_events_emitted!(Event::DelegatorLeft {

3439

1

				delegator: 2,

3440

1

				unstaked_amount: 10

3441

1

});

3442

1

});

3443

1

3444

3445

#[test]

3446

1

fn execute_revoke_delegation_emits_correct_event() {

3447

1

	ExtBuilder::default()

3448

1

		.with_balances(vec![(1, 30), (2, 20), (3, 30)])

3449

1

		.with_candidates(vec![(1, 30), (3, 30)])

3450

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

3451

1

		.build()

3452

1

		.execute_with(|| {

3453

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3454

1

				RuntimeOrigin::signed(2),

3455

3456

));

3457

1

			roll_to(10);

3458

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3459

1

				RuntimeOrigin::signed(2),

3460

2,

3461

3462

));

3463

1

			assert_events_emitted!(Event::DelegatorLeftCandidate {

3464

1

				delegator: 2,

3465

1

				candidate: 1,

3466

1

				unstaked_amount: 10,

3467

1

				total_candidate_staked: 30

3468

1

});

3469

1

});

3470

1

3471

3472

#[test]

3473

1

fn execute_revoke_delegation_unreserves_balance() {

3474

1

	ExtBuilder::default()

3475

1

		.with_balances(vec![(1, 30), (2, 10)])

3476

1

		.with_candidates(vec![(1, 30)])

3477

1

		.with_delegations(vec![(2, 1, 10)])

3478

1

		.build()

3479

1

		.execute_with(|| {

3480

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 0);

3481

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3482

1

				RuntimeOrigin::signed(2),

3483

3484

));

3485

1

			roll_to(10);

3486

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3487

1

				RuntimeOrigin::signed(2),

3488

2,

3489

3490

));

3491

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 10);

3492

1

});

3493

1

3494

3495

#[test]

3496

1

fn execute_revoke_delegation_adds_revocation_to_delegator_state() {

3497

1

	ExtBuilder::default()

3498

1

		.with_balances(vec![(1, 30), (2, 20), (3, 20)])

3499

1

		.with_candidates(vec![(1, 30), (3, 20)])

3500

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

3501

1

		.build()

3502

1

		.execute_with(|| {

3503

1

			assert!(

3504

1

				ParachainStaking::delegation_scheduled_requests(&1, &2).is_empty(),

3505

				"no scheduled requests should exist before scheduling revoke"

3506

);

3507

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3508

1

				RuntimeOrigin::signed(2),

3509

3510

));

3511

1

			assert!(

3512

1

				!ParachainStaking::delegation_scheduled_requests(&1, &2).is_empty(),

3513

				"a scheduled revoke request should exist after scheduling"

3514

);

3515

1

});

3516

1

3517

3518

#[test]

3519

1

fn execute_revoke_delegation_removes_revocation_from_delegator_state_upon_execution() {

3520

1

	ExtBuilder::default()

3521

1

		.with_balances(vec![(1, 30), (2, 20), (3, 20)])

3522

1

		.with_candidates(vec![(1, 30), (3, 20)])

3523

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

3524

1

		.build()

3525

1

		.execute_with(|| {

3526

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3527

1

				RuntimeOrigin::signed(2),

3528

3529

));

3530

1

			roll_to(10);

3531

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3532

1

				RuntimeOrigin::signed(2),

3533

2,

3534

3535

));

3536

1

			assert!(

3537

1

				ParachainStaking::delegation_scheduled_requests(&1, &2).is_empty(),

3538

				"scheduled revoke request should be removed after execution"

3539

);

3540

1

});

3541

1

3542

3543

#[test]

3544

1

fn execute_revoke_delegation_removes_revocation_from_state_for_single_delegation_leave() {

3545

1

	ExtBuilder::default()

3546

1

		.with_balances(vec![(1, 30), (2, 20), (3, 20)])

3547

1

		.with_candidates(vec![(1, 30), (3, 20)])

3548

1

		.with_delegations(vec![(2, 1, 10)])

3549

1

		.build()

3550

1

		.execute_with(|| {

3551

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3552

1

				RuntimeOrigin::signed(2),

3553

3554

));

3555

1

			roll_to(10);

3556

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3557

1

				RuntimeOrigin::signed(2),

3558

2,

3559

3560

));

3561

1

			assert!(

3562

1

				ParachainStaking::delegation_scheduled_requests(&1, &2).is_empty(),

3563

				"delegation request was not removed"

3564

);

3565

1

});

3566

1

3567

3568

#[test]

3569

1

fn execute_revoke_delegation_decreases_total_staked() {

3570

1

	ExtBuilder::default()

3571

1

		.with_balances(vec![(1, 30), (2, 10)])

3572

1

		.with_candidates(vec![(1, 30)])

3573

1

		.with_delegations(vec![(2, 1, 10)])

3574

1

		.build()

3575

1

		.execute_with(|| {

3576

1

			assert_eq!(ParachainStaking::total(), 40);

3577

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3578

1

				RuntimeOrigin::signed(2),

3579

3580

));

3581

1

			roll_to(10);

3582

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3583

1

				RuntimeOrigin::signed(2),

3584

2,

3585

3586

));

3587

1

			assert_eq!(ParachainStaking::total(), 30);

3588

1

});

3589

1

3590

3591

#[test]

3592

1

fn execute_revoke_delegation_for_last_delegation_removes_delegator_state() {

3593

1

	ExtBuilder::default()

3594

1

		.with_balances(vec![(1, 30), (2, 10)])

3595

1

		.with_candidates(vec![(1, 30)])

3596

1

		.with_delegations(vec![(2, 1, 10)])

3597

1

		.build()

3598

1

		.execute_with(|| {

3599

1

			assert!(ParachainStaking::delegator_state(2).is_some());

3600

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3601

1

				RuntimeOrigin::signed(2),

3602

3603

));

3604

1

			roll_to(10);

3605

			// this will be confusing for people

3606

			// if status is leaving, then execute_delegation_request works if last delegation

3607

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3608

1

				RuntimeOrigin::signed(2),

3609

2,

3610

3611

));

3612

1

			assert!(ParachainStaking::delegator_state(2).is_none());

3613

1

});

3614

1

3615

3616

#[test]

3617

1

fn execute_revoke_delegation_removes_delegation_from_candidate_state() {

3618

1

	ExtBuilder::default()

3619

1

		.with_balances(vec![(1, 30), (2, 10)])

3620

1

		.with_candidates(vec![(1, 30)])

3621

1

		.with_delegations(vec![(2, 1, 10)])

3622

1

		.build()

3623

1

		.execute_with(|| {

3624

1

			assert_eq!(

3625

1

				ParachainStaking::candidate_info(1)

3626

1

					.expect("exists")

3627

					.delegation_count,

3628

				1u32

3629

);

3630

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3631

1

				RuntimeOrigin::signed(2),

3632

3633

));

3634

1

			roll_to(10);

3635

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3636

1

				RuntimeOrigin::signed(2),

3637

2,

3638

3639

));

3640

1

			assert!(ParachainStaking::candidate_info(1)

3641

1

				.expect("exists")

3642

1

				.delegation_count

3643

1

				.is_zero());

3644

1

});

3645

1

3646

3647

#[test]

3648

1

fn can_execute_revoke_delegation_for_leaving_candidate() {

3649

1

	ExtBuilder::default()

3650

1

		.with_balances(vec![(1, 30), (2, 10)])

3651

1

		.with_candidates(vec![(1, 30)])

3652

1

		.with_delegations(vec![(2, 1, 10)])

3653

1

		.build()

3654

1

		.execute_with(|| {

3655

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

3656

1

				RuntimeOrigin::signed(1),

3657

3658

));

3659

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3660

1

				RuntimeOrigin::signed(2),

3661

3662

));

3663

1

			roll_to(10);

3664

			// can execute delegation request for leaving candidate

3665

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3666

1

				RuntimeOrigin::signed(2),

3667

2,

3668

3669

));

3670

1

});

3671

1

3672

3673

#[test]

3674

1

fn can_execute_leave_candidates_if_revoking_candidate() {

3675

1

	ExtBuilder::default()

3676

1

		.with_balances(vec![(1, 30), (2, 10)])

3677

1

		.with_candidates(vec![(1, 30)])

3678

1

		.with_delegations(vec![(2, 1, 10)])

3679

1

		.build()

3680

1

		.execute_with(|| {

3681

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

3682

1

				RuntimeOrigin::signed(1),

3683

3684

));

3685

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3686

1

				RuntimeOrigin::signed(2),

3687

3688

));

3689

1

			roll_to(10);

3690

			// revocation executes during execute leave candidates (callable by anyone)

3691

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

3692

1

				RuntimeOrigin::signed(1),

3693

1,

3694

3695

));

3696

1

			assert!(!ParachainStaking::is_delegator(&2));

3697

1

			assert_eq!(Balances::reserved_balance(&2), 0);

3698

1

			assert_eq!(Balances::free_balance(&2), 10);

3699

1

});

3700

1

3701

3702

#[test]

3703

1

fn delegator_bond_more_after_revoke_delegation_does_not_effect_exit() {

3704

1

	ExtBuilder::default()

3705

1

		.with_balances(vec![(1, 30), (2, 30), (3, 30)])

3706

1

		.with_candidates(vec![(1, 30), (3, 30)])

3707

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

3708

1

		.build()

3709

1

		.execute_with(|| {

3710

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3711

1

				RuntimeOrigin::signed(2),

3712

3713

));

3714

1

			assert_ok!(ParachainStaking::delegator_bond_more(

3715

1

				RuntimeOrigin::signed(2),

3716

3,

3717

3718

));

3719

1

			roll_to(100);

3720

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3721

1

				RuntimeOrigin::signed(2),

3722

2,

3723

3724

));

3725

1

			assert!(ParachainStaking::is_delegator(&2));

3726

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 10);

3727

1

});

3728

1

3729

3730

#[test]

3731

1

fn delegator_bond_less_after_revoke_delegation_does_not_effect_exit() {

3732

1

	ExtBuilder::default()

3733

1

		.with_balances(vec![(1, 30), (2, 30), (3, 30)])

3734

1

		.with_candidates(vec![(1, 30), (3, 30)])

3735

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

3736

1

		.build()

3737

1

		.execute_with(|| {

3738

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3739

1

				RuntimeOrigin::signed(2),

3740

3741

));

3742

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

3743

1

				round: 1,

3744

1

				delegator: 2,

3745

1

				candidate: 1,

3746

1

				scheduled_exit: 3,

3747

1

});

3748

1

			assert_noop!(

3749

1

				ParachainStaking::schedule_delegator_bond_less(RuntimeOrigin::signed(2), 1, 2)

3750

1

					.map_err(|err| err.error),

3751

1

				Error::<Test>::PendingDelegationRequestAlreadyExists

3752

);

3753

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3754

1

				RuntimeOrigin::signed(2),

3755

3,

3756

3757

));

3758

1

			roll_to(10);

3759

1

			roll_blocks(1);

3760

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3761

1

				RuntimeOrigin::signed(2),

3762

2,

3763

3764

));

3765

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3766

1

				RuntimeOrigin::signed(2),

3767

2,

3768

3769

));

3770

1

			assert_events_eq!(

3771

1

				Event::DelegatorLeftCandidate {

3772

1

					delegator: 2,

3773

1

					candidate: 1,

3774

1

					unstaked_amount: 10,

3775

1

					total_candidate_staked: 30,

3776

1

},

3777

1

				Event::DelegationRevoked {

3778

1

					delegator: 2,

3779

1

					candidate: 1,

3780

1

					unstaked_amount: 10,

3781

1

},

3782

1

				Event::DelegationDecreased {

3783

1

					delegator: 2,

3784

1

					candidate: 3,

3785

1

					amount: 2,

3786

1

					in_top: true

3787

1

},

3788

);

3789

1

			assert!(ParachainStaking::is_delegator(&2));

3790

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 22);

3791

1

});

3792

1

3793

3794

// 2. EXECUTE BOND LESS

3795

3796

#[test]

3797

1

fn execute_delegator_bond_less_unreserves_balance() {

3798

1

	ExtBuilder::default()

3799

1

		.with_balances(vec![(1, 30), (2, 10)])

3800

1

		.with_candidates(vec![(1, 30)])

3801

1

		.with_delegations(vec![(2, 1, 10)])

3802

1

		.build()

3803

1

		.execute_with(|| {

3804

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 0);

3805

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3806

1

				RuntimeOrigin::signed(2),

3807

1,

3808

3809

));

3810

1

			roll_to(10);

3811

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3812

1

				RuntimeOrigin::signed(2),

3813

2,

3814

3815

));

3816

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 5);

3817

1

});

3818

1

3819

3820

#[test]

3821

1

fn execute_delegator_bond_less_decreases_total_staked() {

3822

1

	ExtBuilder::default()

3823

1

		.with_balances(vec![(1, 30), (2, 10)])

3824

1

		.with_candidates(vec![(1, 30)])

3825

1

		.with_delegations(vec![(2, 1, 10)])

3826

1

		.build()

3827

1

		.execute_with(|| {

3828

1

			assert_eq!(ParachainStaking::total(), 40);

3829

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3830

1

				RuntimeOrigin::signed(2),

3831

1,

3832

3833

));

3834

1

			roll_to(10);

3835

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3836

1

				RuntimeOrigin::signed(2),

3837

2,

3838

3839

));

3840

1

			assert_eq!(ParachainStaking::total(), 35);

3841

1

});

3842

1

3843

3844

#[test]

3845

1

fn execute_delegator_bond_less_updates_delegator_state() {

3846

1

	ExtBuilder::default()

3847

1

		.with_balances(vec![(1, 30), (2, 15)])

3848

1

		.with_candidates(vec![(1, 30)])

3849

1

		.with_delegations(vec![(2, 1, 10)])

3850

1

		.build()

3851

1

		.execute_with(|| {

3852

1

			assert_eq!(

3853

1

				ParachainStaking::delegator_state(2)

3854

1

					.expect("exists")

3855

1

					.total(),

3856

3857

);

3858

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3859

1

				RuntimeOrigin::signed(2),

3860

1,

3861

3862

));

3863

1

			roll_to(10);

3864

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3865

1

				RuntimeOrigin::signed(2),

3866

2,

3867

3868

));

3869

1

			assert_eq!(

3870

1

				ParachainStaking::delegator_state(2)

3871

1

					.expect("exists")

3872

1

					.total(),

3873

3874

);

3875

1

});

3876

1

3877

3878

#[test]

3879

1

fn execute_delegator_bond_less_updates_candidate_state() {

3880

1

	ExtBuilder::default()

3881

1

		.with_balances(vec![(1, 30), (2, 15)])

3882

1

		.with_candidates(vec![(1, 30)])

3883

1

		.with_delegations(vec![(2, 1, 10)])

3884

1

		.build()

3885

1

		.execute_with(|| {

3886

1

			assert_eq!(

3887

1

				ParachainStaking::top_delegations(1).unwrap().delegations[0].owner,

3888

3889

);

3890

1

			assert_eq!(

3891

1

				ParachainStaking::top_delegations(1).unwrap().delegations[0].amount,

3892

3893

);

3894

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3895

1

				RuntimeOrigin::signed(2),

3896

1,

3897

3898

));

3899

1

			roll_to(10);

3900

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3901

1

				RuntimeOrigin::signed(2),

3902

2,

3903

3904

));

3905

1

			assert_eq!(

3906

1

				ParachainStaking::top_delegations(1).unwrap().delegations[0].owner,

3907

3908

);

3909

1

			assert_eq!(

3910

1

				ParachainStaking::top_delegations(1).unwrap().delegations[0].amount,

3911

3912

);

3913

1

});

3914

1

3915

3916

#[test]

3917

1

fn execute_delegator_bond_less_decreases_total() {

3918

1

	ExtBuilder::default()

3919

1

		.with_balances(vec![(1, 30), (2, 15)])

3920

1

		.with_candidates(vec![(1, 30)])

3921

1

		.with_delegations(vec![(2, 1, 10)])

3922

1

		.build()

3923

1

		.execute_with(|| {

3924

1

			assert_eq!(ParachainStaking::total(), 40);

3925

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3926

1

				RuntimeOrigin::signed(2),

3927

1,

3928

3929

));

3930

1

			roll_to(10);

3931

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3932

1

				RuntimeOrigin::signed(2),

3933

2,

3934

3935

));

3936

1

			assert_eq!(ParachainStaking::total(), 35);

3937

1

});

3938

1

3939

3940

#[test]

3941

1

fn execute_delegator_bond_less_updates_just_bottom_delegations() {

3942

1

	ExtBuilder::default()

3943

1

		.with_balances(vec![(1, 20), (2, 10), (3, 11), (4, 12), (5, 14), (6, 15)])

3944

1

		.with_candidates(vec![(1, 20)])

3945

1

		.with_delegations(vec![

3946

1

			(2, 1, 10),

3947

1

			(3, 1, 11),

3948

1

			(4, 1, 12),

3949

1

			(5, 1, 14),

3950

1

			(6, 1, 15),

3951

1

])

3952

1

		.build()

3953

1

		.execute_with(|| {

3954

1

			let pre_call_candidate_info =

3955

1

				ParachainStaking::candidate_info(&1).expect("delegated by all so exists");

3956

1

			let pre_call_top_delegations =

3957

1

				ParachainStaking::top_delegations(&1).expect("delegated by all so exists");

3958

1

			let pre_call_bottom_delegations =

3959

1

				ParachainStaking::bottom_delegations(&1).expect("delegated by all so exists");

3960

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3961

1

				RuntimeOrigin::signed(2),

3962

1,

3963

3964

));

3965

1

			roll_to(10);

3966

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3967

1

				RuntimeOrigin::signed(2),

3968

2,

3969

3970

));

3971

1

			let post_call_candidate_info =

3972

1

				ParachainStaking::candidate_info(&1).expect("delegated by all so exists");

3973

1

			let post_call_top_delegations =

3974

1

				ParachainStaking::top_delegations(&1).expect("delegated by all so exists");

3975

1

			let post_call_bottom_delegations =

3976

1

				ParachainStaking::bottom_delegations(&1).expect("delegated by all so exists");

3977

1

			let mut not_equal = false;

3978

2

			for Bond { owner, amount } in pre_call_bottom_delegations.delegations {

3979

				for Bond {

3980

1

					owner: post_owner,

3981

1

					amount: post_amount,

3982

1

				} in &post_call_bottom_delegations.delegations

3983

3984

1

					if &owner == post_owner {

3985

1

						if &amount != post_amount {

3986

1

							not_equal = true;

3987

1

							break;

3988

3989

3990

3991

3992

1

			assert!(not_equal);

3993

1

			let mut equal = true;

3994

5

			for Bond { owner, amount } in pre_call_top_delegations.delegations {

3995

				for Bond {

3996

16

					owner: post_owner,

3997

16

					amount: post_amount,

3998

20

				} in &post_call_top_delegations.delegations

3999

4000

16

					if &owner == post_owner {

4001

4

						if &amount != post_amount {

4002

							equal = false;

4003

							break;

4004

4

4005

12

4006

4007

4008

1

			assert!(equal);

4009

1

			assert_eq!(

4010

				pre_call_candidate_info.total_counted,

4011

				post_call_candidate_info.total_counted

4012

);

4013

1

});

4014

1

4015

4016

#[test]

4017

1

fn execute_delegator_bond_less_does_not_delete_bottom_delegations() {

4018

1

	ExtBuilder::default()

4019

1

		.with_balances(vec![(1, 20), (2, 10), (3, 11), (4, 12), (5, 14), (6, 15)])

4020

1

		.with_candidates(vec![(1, 20)])

4021

1

		.with_delegations(vec![

4022

1

			(2, 1, 10),

4023

1

			(3, 1, 11),

4024

1

			(4, 1, 12),

4025

1

			(5, 1, 14),

4026

1

			(6, 1, 15),

4027

1

])

4028

1

		.build()

4029

1

		.execute_with(|| {

4030

1

			let pre_call_candidate_info =

4031

1

				ParachainStaking::candidate_info(&1).expect("delegated by all so exists");

4032

1

			let pre_call_top_delegations =

4033

1

				ParachainStaking::top_delegations(&1).expect("delegated by all so exists");

4034

1

			let pre_call_bottom_delegations =

4035

1

				ParachainStaking::bottom_delegations(&1).expect("delegated by all so exists");

4036

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

4037

1

				RuntimeOrigin::signed(6),

4038

1,

4039

4040

));

4041

1

			roll_to(10);

4042

1

			assert_ok!(ParachainStaking::execute_delegation_request(

4043

1

				RuntimeOrigin::signed(6),

4044

6,

4045

4046

));

4047

1

			let post_call_candidate_info =

4048

1

				ParachainStaking::candidate_info(&1).expect("delegated by all so exists");

4049

1

			let post_call_top_delegations =

4050

1

				ParachainStaking::top_delegations(&1).expect("delegated by all so exists");

4051

1

			let post_call_bottom_delegations =

4052

1

				ParachainStaking::bottom_delegations(&1).expect("delegated by all so exists");

4053

1

			let mut equal = true;

4054

2

			for Bond { owner, amount } in pre_call_bottom_delegations.delegations {

4055

				for Bond {

4056

1

					owner: post_owner,

4057

1

					amount: post_amount,

4058

2

				} in &post_call_bottom_delegations.delegations

4059

4060

1

					if &owner == post_owner {

4061

1

						if &amount != post_amount {

4062

							equal = false;

4063

							break;

4064

1

4065

4066

4067

4068

1

			assert!(equal);

4069

1

			let mut not_equal = false;

4070

5

			for Bond { owner, amount } in pre_call_top_delegations.delegations {

4071

				for Bond {

4072

15

					owner: post_owner,

4073

15

					amount: post_amount,

4074

18

				} in &post_call_top_delegations.delegations

4075

4076

15

					if &owner == post_owner {

4077

4

						if &amount != post_amount {

4078

1

							not_equal = true;

4079

1

							break;

4080

3

4081

11

4082

4083

4084

1

			assert!(not_equal);

4085

1

			assert_eq!(

4086

1

				pre_call_candidate_info.total_counted - 4,

4087

				post_call_candidate_info.total_counted

4088

);

4089

1

});

4090

1

4091

4092

#[test]

4093

1

fn can_execute_delegator_bond_less_for_leaving_candidate() {

4094

1

	ExtBuilder::default()

4095

1

		.with_balances(vec![(1, 30), (2, 15)])

4096

1

		.with_candidates(vec![(1, 30)])

4097

1

		.with_delegations(vec![(2, 1, 15)])

4098

1

		.build()

4099

1

		.execute_with(|| {

4100

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

4101

1

				RuntimeOrigin::signed(1),

4102

4103

));

4104

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

4105

1

				RuntimeOrigin::signed(2),

4106

1,

4107

4108

));

4109

1

			roll_to(10);

4110

			// can execute bond more delegation request for leaving candidate

4111

1

			assert_ok!(ParachainStaking::execute_delegation_request(

4112

1

				RuntimeOrigin::signed(2),

4113

2,

4114

4115

));

4116

1

});

4117

1

4118

4119

// CANCEL PENDING DELEGATION REQUEST

4120

// 1. CANCEL REVOKE DELEGATION

4121

4122

#[test]

4123

1

fn cancel_revoke_delegation_emits_correct_event() {

4124

1

	ExtBuilder::default()

4125

1

		.with_balances(vec![(1, 30), (2, 10)])

4126

1

		.with_candidates(vec![(1, 30)])

4127

1

		.with_delegations(vec![(2, 1, 10)])

4128

1

		.build()

4129

1

		.execute_with(|| {

4130

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4131

1

				RuntimeOrigin::signed(2),

4132

4133

));

4134

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

4135

1

				RuntimeOrigin::signed(2),

4136

4137

));

4138

1

			assert_events_emitted!(Event::CancelledDelegationRequest {

4139

1

				delegator: 2,

4140

1

				collator: 1,

4141

1

				cancelled_request: CancelledScheduledRequest {

4142

1

					when_executable: 3,

4143

1

					action: DelegationAction::Revoke(10),

4144

1

},

4145

1

});

4146

1

});

4147

1

4148

4149

#[test]

4150

1

fn cancel_revoke_delegation_updates_delegator_state() {

4151

1

	ExtBuilder::default()

4152

1

		.with_balances(vec![(1, 30), (2, 10)])

4153

1

		.with_candidates(vec![(1, 30)])

4154

1

		.with_delegations(vec![(2, 1, 10)])

4155

1

		.build()

4156

1

		.execute_with(|| {

4157

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4158

1

				RuntimeOrigin::signed(2),

4159

4160

));

4161

1

			let state = ParachainStaking::delegation_scheduled_requests(&1, &2);

4162

1

			assert_eq!(

4163

				state,

4164

1

				vec![ScheduledRequest {

4165

1

					when_executable: 3,

4166

1

					action: DelegationAction::Revoke(10),

4167

1

}],

4168

);

4169

1

			assert_eq!(

4170

1

				ParachainStaking::delegator_state(&2)

4171

1

					.map(|x| x.less_total)

4172

1

					.expect("delegator state must exist"),

4173

4174

);

4175

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

4176

1

				RuntimeOrigin::signed(2),

4177

4178

));

4179

1

			assert!(

4180

1

				ParachainStaking::delegation_scheduled_requests(&1, &2).is_empty(),

4181

				"scheduled revoke request should be removed after cancel"

4182

);

4183

1

			assert_eq!(

4184

1

				ParachainStaking::delegator_state(&2)

4185

1

					.map(|x| x.less_total)

4186

1

					.expect("delegator state must exist"),

4187

4188

);

4189

1

});

4190

1

4191

4192

// 2. CANCEL DELEGATOR BOND LESS

4193

4194

#[test]

4195

1

fn cancel_delegator_bond_less_correct_event() {

4196

1

	ExtBuilder::default()

4197

1

		.with_balances(vec![(1, 30), (2, 15)])

4198

1

		.with_candidates(vec![(1, 30)])

4199

1

		.with_delegations(vec![(2, 1, 15)])

4200

1

		.build()

4201

1

		.execute_with(|| {

4202

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

4203

1

				RuntimeOrigin::signed(2),

4204

1,

4205

4206

));

4207

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

4208

1

				RuntimeOrigin::signed(2),

4209

4210

));

4211

1

			assert_events_emitted!(Event::CancelledDelegationRequest {

4212

1

				delegator: 2,

4213

1

				collator: 1,

4214

1

				cancelled_request: CancelledScheduledRequest {

4215

1

					when_executable: 3,

4216

1

					action: DelegationAction::Decrease(5),

4217

1

},

4218

1

});

4219

1

});

4220

1

4221

4222

#[test]

4223

1

fn cancel_delegator_bond_less_updates_delegator_state() {

4224

1

	ExtBuilder::default()

4225

1

		.with_balances(vec![(1, 30), (2, 15)])

4226

1

		.with_candidates(vec![(1, 30)])

4227

1

		.with_delegations(vec![(2, 1, 15)])

4228

1

		.build()

4229

1

		.execute_with(|| {

4230

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

4231

1

				RuntimeOrigin::signed(2),

4232

1,

4233

4234

));

4235

1

			let state = ParachainStaking::delegation_scheduled_requests(&1, &2);

4236

1

			assert_eq!(

4237

				state,

4238

1

				vec![ScheduledRequest {

4239

1

					when_executable: 3,

4240

1

					action: DelegationAction::Decrease(5),

4241

1

}],

4242

);

4243

1

			assert_eq!(

4244

1

				ParachainStaking::delegator_state(&2)

4245

1

					.map(|x| x.less_total)

4246

1

					.expect("delegator state must exist"),

4247

4248

);

4249

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

4250

1

				RuntimeOrigin::signed(2),

4251

4252

));

4253

1

			assert!(

4254

1

				ParachainStaking::delegation_scheduled_requests(&1, &2).is_empty(),

4255

				"scheduled bond-less request should be removed after cancel"

4256

);

4257

1

			assert_eq!(

4258

1

				ParachainStaking::delegator_state(&2)

4259

1

					.map(|x| x.less_total)

4260

1

					.expect("delegator state must exist"),

4261

4262

);

4263

1

});

4264

1

4265

4266

// ~~ PROPERTY-BASED TESTS ~~

4267

4268

#[test]

4269

1

fn delegator_schedule_revocation_total() {

4270

1

	ExtBuilder::default()

4271

1

		.with_balances(vec![(1, 20), (2, 40), (3, 20), (4, 20), (5, 20)])

4272

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20), (5, 20)])

4273

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10), (2, 4, 10)])

4274

1

		.build()

4275

1

		.execute_with(|| {

4276

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4277

1

				RuntimeOrigin::signed(2),

4278

4279

));

4280

1

			assert_eq!(

4281

1

				ParachainStaking::delegator_state(&2)

4282

1

					.map(|x| x.less_total)

4283

1

					.expect("delegator state must exist"),

4284

4285

);

4286

1

			roll_to(10);

4287

1

			assert_ok!(ParachainStaking::execute_delegation_request(

4288

1

				RuntimeOrigin::signed(2),

4289

2,

4290

4291

));

4292

1

			assert_eq!(

4293

1

				ParachainStaking::delegator_state(&2)

4294

1

					.map(|x| x.less_total)

4295

1

					.expect("delegator state must exist"),

4296

4297

);

4298

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4299

1

				RuntimeOrigin::signed(2),

4300

5,

4301

10,

4302

1

				Percent::zero(),

4303

0,

4304

0,

4305

4306

));

4307

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4308

1

				RuntimeOrigin::signed(2),

4309

4310

));

4311

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4312

1

				RuntimeOrigin::signed(2),

4313

4314

));

4315

1

			assert_eq!(

4316

1

				ParachainStaking::delegator_state(&2)

4317

1

					.map(|x| x.less_total)

4318

1

					.expect("delegator state must exist"),

4319

20,

4320

);

4321

1

			roll_to(20);

4322

1

			assert_ok!(ParachainStaking::execute_delegation_request(

4323

1

				RuntimeOrigin::signed(2),

4324

2,

4325

4326

));

4327

1

			assert_eq!(

4328

1

				ParachainStaking::delegator_state(&2)

4329

1

					.map(|x| x.less_total)

4330

1

					.expect("delegator state must exist"),

4331

10,

4332

);

4333

1

			assert_ok!(ParachainStaking::execute_delegation_request(

4334

1

				RuntimeOrigin::signed(2),

4335

2,

4336

4337

));

4338

1

			assert_eq!(

4339

1

				ParachainStaking::delegator_state(&2)

4340

1

					.map(|x| x.less_total)

4341

1

					.expect("delegator state must exist"),

4342

4343

);

4344

1

});

4345

1

4346

4347

#[test]

4348

1

fn paid_collator_commission_matches_config() {

4349

1

	ExtBuilder::default()

4350

1

		.with_balances(vec![

4351

1

			(1, 100),

4352

1

			(2, 100),

4353

1

			(3, 100),

4354

1

			(4, 100),

4355

1

			(5, 100),

4356

1

			(6, 100),

4357

1

])

4358

1

		.with_candidates(vec![(1, 20)])

4359

1

		.with_delegations(vec![(2, 1, 10), (3, 1, 10)])

4360

1

		.build()

4361

1

		.execute_with(|| {

4362

1

			roll_to_round_begin(2);

4363

1

			assert_ok!(ParachainStaking::join_candidates(

4364

1

				RuntimeOrigin::signed(4),

4365

				20u128,

4366

				100u32

4367

));

4368

1

			assert_events_eq!(

4369

1

				Event::CollatorChosen {

4370

1

					round: 2,

4371

1

					collator_account: 1,

4372

1

					total_exposed_amount: 40,

4373

1

},

4374

1

				Event::NewRound {

4375

1

					starting_block: 5,

4376

1

					round: 2,

4377

1

					selected_collators_number: 1,

4378

1

					total_balance: 40,

4379

1

},

4380

1

				Event::JoinedCollatorCandidates {

4381

1

					account: 4,

4382

1

					amount_locked: 20,

4383

1

					new_total_amt_locked: 60,

4384

1

},

4385

);

4386

4387

1

			roll_blocks(1);

4388

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4389

1

				RuntimeOrigin::signed(5),

4390

4,

4391

10,

4392

1

				Percent::zero(),

4393

10,

4394

0,

4395

4396

));

4397

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4398

1

				RuntimeOrigin::signed(6),

4399

4,

4400

10,

4401

1

				Percent::zero(),

4402

10,

4403

0,

4404

4405

));

4406

1

			assert_events_eq!(

4407

1

				Event::Delegation {

4408

1

					delegator: 5,

4409

1

					locked_amount: 10,

4410

1

					candidate: 4,

4411

1

					delegator_position: DelegatorAdded::AddedToTop { new_total: 30 },

4412

1

					auto_compound: Percent::zero(),

4413

1

},

4414

1

				Event::Delegation {

4415

1

					delegator: 6,

4416

1

					locked_amount: 10,

4417

1

					candidate: 4,

4418

1

					delegator_position: DelegatorAdded::AddedToTop { new_total: 40 },

4419

1

					auto_compound: Percent::zero(),

4420

1

},

4421

);

4422

4423

1

			roll_to_round_begin(3);

4424

1

			assert_events_eq!(

4425

1

				Event::CollatorChosen {

4426

1

					round: 3,

4427

1

					collator_account: 1,

4428

1

					total_exposed_amount: 40,

4429

1

},

4430

1

				Event::CollatorChosen {

4431

1

					round: 3,

4432

1

					collator_account: 4,

4433

1

					total_exposed_amount: 40,

4434

1

},

4435

1

				Event::NewRound {

4436

1

					starting_block: 10,

4437

1

					round: 3,

4438

1

					selected_collators_number: 2,

4439

1

					total_balance: 80,

4440

1

},

4441

);

4442

			// only reward author with id 4

4443

1

			set_author(3, 4, POINTS_PER_ROUND);

4444

1

			roll_to_round_begin(5);

4445

			// 20% of 10 is commission + due_portion (0) = 2 + 4 = 6

4446

			// all delegator payouts are 10-2 = 8 * stake_pct

4447

1

			assert_events_eq!(

4448

1

				Event::CollatorChosen {

4449

1

					round: 5,

4450

1

					collator_account: 1,

4451

1

					total_exposed_amount: 40,

4452

1

},

4453

1

				Event::CollatorChosen {

4454

1

					round: 5,

4455

1

					collator_account: 4,

4456

1

					total_exposed_amount: 40,

4457

1

},

4458

1

				Event::NewRound {

4459

1

					starting_block: 20,

4460

1

					round: 5,

4461

1

					selected_collators_number: 2,

4462

1

					total_balance: 80,

4463

1

},

4464

);

4465

4466

1

			roll_blocks(1);

4467

1

			assert_events_eq!(

4468

1

				Event::Rewarded {

4469

1

					account: 4,

4470

1

					rewards: 9,

4471

1

},

4472

1

				Event::Rewarded {

4473

1

					account: 5,

4474

1

					rewards: 3,

4475

1

},

4476

1

				Event::Rewarded {

4477

1

					account: 6,

4478

1

					rewards: 3,

4479

1

},

4480

);

4481

1

});

4482

1

4483

4484

#[test]

4485

1

fn collator_exit_executes_after_delay() {

4486

1

	ExtBuilder::default()

4487

1

		.with_balances(vec![

4488

1

			(1, 1000),

4489

1

			(2, 300),

4490

1

			(3, 100),

4491

1

			(4, 100),

4492

1

			(5, 100),

4493

1

			(6, 100),

4494

1

			(7, 100),

4495

1

			(8, 9),

4496

1

			(9, 4),

4497

1

])

4498

1

		.with_candidates(vec![(1, 500), (2, 200)])

4499

1

		.with_delegations(vec![(3, 1, 100), (4, 1, 100), (5, 2, 100), (6, 2, 100)])

4500

1

		.build()

4501

1

		.execute_with(|| {

4502

1

			roll_to(11);

4503

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

4504

1

				RuntimeOrigin::signed(2),

4505

4506

));

4507

1

			assert_events_eq!(Event::CandidateScheduledExit {

4508

1

				exit_allowed_round: 3,

4509

1

				candidate: 2,

4510

1

				scheduled_exit: 5,

4511

1

});

4512

1

			let info = ParachainStaking::candidate_info(&2).unwrap();

4513

1

			assert_eq!(info.status, CollatorStatus::Leaving(5));

4514

1

			roll_to(21);

4515

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

4516

1

				RuntimeOrigin::signed(2),

4517

2,

4518

4519

));

4520

			// we must exclude leaving collators from rewards while

4521

			// holding them retroactively accountable for previous faults

4522

			// (within the last T::SlashingWindow blocks)

4523

1

			assert_events_eq!(Event::CandidateLeft {

4524

1

				ex_candidate: 2,

4525

1

				unlocked_amount: 400,

4526

1

				new_total_amt_locked: 700,

4527

1

			},);

4528

1

});

4529

1

4530

4531

#[test]

4532

1

fn collator_selection_chooses_top_candidates() {

4533

1

	ExtBuilder::default()

4534

1

		.with_balances(vec![

4535

1

			(1, 1000),

4536

1

			(2, 1000),

4537

1

			(3, 1000),

4538

1

			(4, 1000),

4539

1

			(5, 1000),

4540

1

			(6, 1000),

4541

1

			(7, 33),

4542

1

			(8, 33),

4543

1

			(9, 33),

4544

1

])

4545

1

		.with_candidates(vec![(1, 100), (2, 90), (3, 80), (4, 70), (5, 60), (6, 50)])

4546

1

		.build()

4547

1

		.execute_with(|| {

4548

1

			roll_to_round_begin(2);

4549

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

4550

1

				RuntimeOrigin::signed(6),

4551

4552

));

4553

			// should choose top TotalSelectedCandidates (5), in order

4554

1

			assert_events_eq!(

4555

1

				Event::CollatorChosen {

4556

1

					round: 2,

4557

1

					collator_account: 1,

4558

1

					total_exposed_amount: 100,

4559

1

},

4560

1

				Event::CollatorChosen {

4561

1

					round: 2,

4562

1

					collator_account: 2,

4563

1

					total_exposed_amount: 90,

4564

1

},

4565

1

				Event::CollatorChosen {

4566

1

					round: 2,

4567

1

					collator_account: 3,

4568

1

					total_exposed_amount: 80,

4569

1

},

4570

1

				Event::CollatorChosen {

4571

1

					round: 2,

4572

1

					collator_account: 4,

4573

1

					total_exposed_amount: 70,

4574

1

},

4575

1

				Event::CollatorChosen {

4576

1

					round: 2,

4577

1

					collator_account: 5,

4578

1

					total_exposed_amount: 60,

4579

1

},

4580

1

				Event::NewRound {

4581

1

					starting_block: 5,

4582

1

					round: 2,

4583

1

					selected_collators_number: 5,

4584

1

					total_balance: 400,

4585

1

},

4586

1

				Event::CandidateScheduledExit {

4587

1

					exit_allowed_round: 2,

4588

1

					candidate: 6,

4589

1

					scheduled_exit: 4

4590

1

},

4591

);

4592

1

			roll_to_round_begin(4);

4593

1

			roll_blocks(1);

4594

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

4595

1

				RuntimeOrigin::signed(6),

4596

6,

4597

4598

));

4599

1

			assert_ok!(ParachainStaking::join_candidates(

4600

1

				RuntimeOrigin::signed(6),

4601

				69u128,

4602

				100u32

4603

));

4604

1

			assert_events_eq!(

4605

1

				Event::CandidateLeft {

4606

1

					ex_candidate: 6,

4607

1

					unlocked_amount: 50,

4608

1

					new_total_amt_locked: 400,

4609

1

},

4610

1

				Event::JoinedCollatorCandidates {

4611

1

					account: 6,

4612

1

					amount_locked: 69u128,

4613

1

					new_total_amt_locked: 469u128,

4614

1

},

4615

);

4616

1

			roll_to_round_begin(6);

4617

			// should choose top TotalSelectedCandidates (5), in order

4618

1

			assert_events_eq!(

4619

1

				Event::CollatorChosen {

4620

1

					round: 6,

4621

1

					collator_account: 1,

4622

1

					total_exposed_amount: 100,

4623

1

},

4624

1

				Event::CollatorChosen {

4625

1

					round: 6,

4626

1

					collator_account: 2,

4627

1

					total_exposed_amount: 90,

4628

1

},

4629

1

				Event::CollatorChosen {

4630

1

					round: 6,

4631

1

					collator_account: 3,

4632

1

					total_exposed_amount: 80,

4633

1

},

4634

1

				Event::CollatorChosen {

4635

1

					round: 6,

4636

1

					collator_account: 4,

4637

1

					total_exposed_amount: 70,

4638

1

},

4639

1

				Event::CollatorChosen {

4640

1

					round: 6,

4641

1

					collator_account: 6,

4642

1

					total_exposed_amount: 69,

4643

1

},

4644

1

				Event::NewRound {

4645

1

					starting_block: 25,

4646

1

					round: 6,

4647

1

					selected_collators_number: 5,

4648

1

					total_balance: 409,

4649

1

},

4650

);

4651

1

});

4652

1

4653

4654

#[test]

4655

1

fn payout_distribution_to_solo_collators() {

4656

1

	ExtBuilder::default()

4657

1

		.with_balances(vec![

4658

1

			(1, 1000),

4659

1

			(2, 1000),

4660

1

			(3, 1000),

4661

1

			(4, 1000),

4662

1

			(7, 33),

4663

1

			(8, 33),

4664

1

			(9, 33),

4665

1

])

4666

1

		.with_candidates(vec![(1, 100), (2, 90), (3, 80), (4, 70)])

4667

1

		.build()

4668

1

		.execute_with(|| {

4669

1

			roll_to_round_begin(2);

4670

			// should choose top TotalCandidatesSelected (5), in order

4671

1

			assert_events_eq!(

4672

1

				Event::CollatorChosen {

4673

1

					round: 2,

4674

1

					collator_account: 1,

4675

1

					total_exposed_amount: 100,

4676

1

},

4677

1

				Event::CollatorChosen {

4678

1

					round: 2,

4679

1

					collator_account: 2,

4680

1

					total_exposed_amount: 90,

4681

1

},

4682

1

				Event::CollatorChosen {

4683

1

					round: 2,

4684

1

					collator_account: 3,

4685

1

					total_exposed_amount: 80,

4686

1

},

4687

1

				Event::CollatorChosen {

4688

1

					round: 2,

4689

1

					collator_account: 4,

4690

1

					total_exposed_amount: 70,

4691

1

},

4692

1

				Event::NewRound {

4693

1

					starting_block: 5,

4694

1

					round: 2,

4695

1

					selected_collators_number: 4,

4696

1

					total_balance: 340,

4697

1

},

4698

);

4699

			// ~ set block author as 1 for all blocks this round

4700

1

			set_author(2, 1, POINTS_PER_ROUND);

4701

1

			roll_to_round_begin(4);

4702

1

			assert_events_eq!(

4703

1

				Event::CollatorChosen {

4704

1

					round: 4,

4705

1

					collator_account: 1,

4706

1

					total_exposed_amount: 100,

4707

1

},

4708

1

				Event::CollatorChosen {

4709

1

					round: 4,

4710

1

					collator_account: 2,

4711

1

					total_exposed_amount: 90,

4712

1

},

4713

1

				Event::CollatorChosen {

4714

1

					round: 4,

4715

1

					collator_account: 3,

4716

1

					total_exposed_amount: 80,

4717

1

},

4718

1

				Event::CollatorChosen {

4719

1

					round: 4,

4720

1

					collator_account: 4,

4721

1

					total_exposed_amount: 70,

4722

1

},

4723

1

				Event::NewRound {

4724

1

					starting_block: 15,

4725

1

					round: 4,

4726

1

					selected_collators_number: 4,

4727

1

					total_balance: 340,

4728

1

},

4729

);

4730

			// pay total issuance to 1 at 2nd block

4731

1

			roll_blocks(3);

4732

1

			assert_events_eq!(Event::Rewarded {

4733

1

				account: 1,

4734

1

				rewards: 102,

4735

1

});

4736

			// ~ set block author as 1 for 3 blocks this round

4737

1

			set_author(4, 1, POINTS_PER_BLOCK * 3);

4738

			// ~ set block author as 2 for 2 blocks this round

4739

1

			set_author(4, 2, POINTS_PER_BLOCK * 2);

4740

1

			roll_to_round_begin(6);

4741

			// pay 60% total issuance to 1 and 40% total issuance to 2

4742

1

			assert_events_eq!(

4743

1

				Event::CollatorChosen {

4744

1

					round: 6,

4745

1

					collator_account: 1,

4746

1

					total_exposed_amount: 100,

4747

1

},

4748

1

				Event::CollatorChosen {

4749

1

					round: 6,

4750

1

					collator_account: 2,

4751

1

					total_exposed_amount: 90,

4752

1

},

4753

1

				Event::CollatorChosen {

4754

1

					round: 6,

4755

1

					collator_account: 3,

4756

1

					total_exposed_amount: 80,

4757

1

},

4758

1

				Event::CollatorChosen {

4759

1

					round: 6,

4760

1

					collator_account: 4,

4761

1

					total_exposed_amount: 70,

4762

1

},

4763

1

				Event::NewRound {

4764

1

					starting_block: 25,

4765

1

					round: 6,

4766

1

					selected_collators_number: 4,

4767

1

					total_balance: 340,

4768

1

},

4769

);

4770

1

			roll_blocks(3);

4771

1

			assert_events_eq!(Event::Rewarded {

4772

1

				account: 1,

4773

1

				rewards: 63,

4774

1

});

4775

1

			roll_blocks(1);

4776

1

			assert_events_eq!(Event::Rewarded {

4777

1

				account: 2,

4778

1

				rewards: 42,

4779

1

			},);

4780

			// ~ each collator produces at least 1 block this round

4781

1

			set_author(6, 1, POINTS_PER_BLOCK * 2);

4782

1

			set_author(6, 2, POINTS_PER_BLOCK);

4783

1

			set_author(6, 3, POINTS_PER_BLOCK);

4784

1

			set_author(6, 4, POINTS_PER_BLOCK);

4785

1

			roll_to_round_begin(8);

4786

			// pay 20% issuance for all collators

4787

1

			assert_events_eq!(

4788

1

				Event::CollatorChosen {

4789

1

					round: 8,

4790

1

					collator_account: 1,

4791

1

					total_exposed_amount: 100,

4792

1

},

4793

1

				Event::CollatorChosen {

4794

1

					round: 8,

4795

1

					collator_account: 2,

4796

1

					total_exposed_amount: 90,

4797

1

},

4798

1

				Event::CollatorChosen {

4799

1

					round: 8,

4800

1

					collator_account: 3,

4801

1

					total_exposed_amount: 80,

4802

1

},

4803

1

				Event::CollatorChosen {

4804

1

					round: 8,

4805

1

					collator_account: 4,

4806

1

					total_exposed_amount: 70,

4807

1

},

4808

1

				Event::NewRound {

4809

1

					starting_block: 35,

4810

1

					round: 8,

4811

1

					selected_collators_number: 4,

4812

1

					total_balance: 340,

4813

1

},

4814

);

4815

1

			roll_blocks(1);

4816

1

			assert_events_eq!(Event::Rewarded {

4817

1

				account: 3,

4818

1

				rewards: 21,

4819

1

});

4820

1

			roll_blocks(1);

4821

1

			assert_events_eq!(Event::Rewarded {

4822

1

				account: 4,

4823

1

				rewards: 21,

4824

1

});

4825

1

			roll_blocks(1);

4826

1

			assert_events_eq!(Event::Rewarded {

4827

1

				account: 1,

4828

1

				rewards: 43,

4829

1

});

4830

1

			roll_blocks(1);

4831

1

			assert_events_eq!(Event::Rewarded {

4832

1

				account: 2,

4833

1

				rewards: 21,

4834

1

});

4835

			// check that distributing rewards clears awarded pts

4836

1

			assert!(ParachainStaking::awarded_pts(1, 1).is_zero());

4837

1

			assert!(ParachainStaking::awarded_pts(4, 1).is_zero());

4838

1

			assert!(ParachainStaking::awarded_pts(4, 2).is_zero());

4839

1

			assert!(ParachainStaking::awarded_pts(6, 1).is_zero());

4840

1

			assert!(ParachainStaking::awarded_pts(6, 2).is_zero());

4841

1

			assert!(ParachainStaking::awarded_pts(6, 3).is_zero());

4842

1

			assert!(ParachainStaking::awarded_pts(6, 4).is_zero());

4843

1

});

4844

1

4845

4846

#[test]

4847

1

fn multiple_delegations() {

4848

1

	ExtBuilder::default()

4849

1

		.with_balances(vec![

4850

1

			(1, 100),

4851

1

			(2, 100),

4852

1

			(3, 100),

4853

1

			(4, 100),

4854

1

			(5, 100),

4855

1

			(6, 100),

4856

1

			(7, 100),

4857

1

			(8, 100),

4858

1

			(9, 100),

4859

1

			(10, 100),

4860

1

])

4861

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20), (5, 10)])

4862

1

		.with_delegations(vec![

4863

1

			(6, 1, 10),

4864

1

			(7, 1, 10),

4865

1

			(8, 2, 10),

4866

1

			(9, 2, 10),

4867

1

			(10, 1, 10),

4868

1

])

4869

1

		.build()

4870

1

		.execute_with(|| {

4871

1

			roll_to_round_begin(2);

4872

			// chooses top TotalSelectedCandidates (5), in order

4873

1

			assert_events_eq!(

4874

1

				Event::CollatorChosen {

4875

1

					round: 2,

4876

1

					collator_account: 1,

4877

1

					total_exposed_amount: 50,

4878

1

},

4879

1

				Event::CollatorChosen {

4880

1

					round: 2,

4881

1

					collator_account: 2,

4882

1

					total_exposed_amount: 40,

4883

1

},

4884

1

				Event::CollatorChosen {

4885

1

					round: 2,

4886

1

					collator_account: 3,

4887

1

					total_exposed_amount: 20,

4888

1

},

4889

1

				Event::CollatorChosen {

4890

1

					round: 2,

4891

1

					collator_account: 4,

4892

1

					total_exposed_amount: 20,

4893

1

},

4894

1

				Event::CollatorChosen {

4895

1

					round: 2,

4896

1

					collator_account: 5,

4897

1

					total_exposed_amount: 10,

4898

1

},

4899

1

				Event::NewRound {

4900

1

					starting_block: 5,

4901

1

					round: 2,

4902

1

					selected_collators_number: 5,

4903

1

					total_balance: 140,

4904

1

},

4905

);

4906

1

			roll_blocks(1);

4907

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4908

1

				RuntimeOrigin::signed(6),

4909

2,

4910

10,

4911

1

				Percent::zero(),

4912

10,

4913

0,

4914

4915

));

4916

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4917

1

				RuntimeOrigin::signed(6),

4918

3,

4919

10,

4920

1

				Percent::zero(),

4921

10,

4922

0,

4923

4924

));

4925

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4926

1

				RuntimeOrigin::signed(6),

4927

4,

4928

10,

4929

1

				Percent::zero(),

4930

10,

4931

0,

4932

4933

));

4934

1

			assert_events_eq!(

4935

1

				Event::Delegation {

4936

1

					delegator: 6,

4937

1

					locked_amount: 10,

4938

1

					candidate: 2,

4939

1

					delegator_position: DelegatorAdded::AddedToTop { new_total: 50 },

4940

1

					auto_compound: Percent::zero(),

4941

1

},

4942

1

				Event::Delegation {

4943

1

					delegator: 6,

4944

1

					locked_amount: 10,

4945

1

					candidate: 3,

4946

1

					delegator_position: DelegatorAdded::AddedToTop { new_total: 30 },

4947

1

					auto_compound: Percent::zero(),

4948

1

},

4949

1

				Event::Delegation {

4950

1

					delegator: 6,

4951

1

					locked_amount: 10,

4952

1

					candidate: 4,

4953

1

					delegator_position: DelegatorAdded::AddedToTop { new_total: 30 },

4954

1

					auto_compound: Percent::zero(),

4955

1

},

4956

);

4957

1

			roll_to_round_begin(6);

4958

1

			roll_blocks(1);

4959

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4960

1

				RuntimeOrigin::signed(7),

4961

2,

4962

80,

4963

1

				Percent::zero(),

4964

10,

4965

0,

4966

4967

));

4968

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4969

1

				RuntimeOrigin::signed(10),

4970

2,

4971

10,

4972

1

				Percent::zero(),

4973

10,

4974

0,

4975

4976

));

4977

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

4978

1

				RuntimeOrigin::signed(2),

4979

4980

));

4981

1

			assert_events_eq!(

4982

1

				Event::Delegation {

4983

1

					delegator: 7,

4984

1

					locked_amount: 80,

4985

1

					candidate: 2,

4986

1

					delegator_position: DelegatorAdded::AddedToTop { new_total: 130 },

4987

1

					auto_compound: Percent::zero(),

4988

1

},

4989

1

				Event::Delegation {

4990

1

					delegator: 10,

4991

1

					locked_amount: 10,

4992

1

					candidate: 2,

4993

1

					delegator_position: DelegatorAdded::AddedToBottom,

4994

1

					auto_compound: Percent::zero(),

4995

1

},

4996

1

				Event::CandidateScheduledExit {

4997

1

					exit_allowed_round: 6,

4998

1

					candidate: 2,

4999

1

					scheduled_exit: 8

5000

1

},

5001

);

5002

1

			roll_to_round_begin(7);

5003

1

			assert_events_eq!(

5004

1

				Event::CollatorChosen {

5005

1

					round: 7,

5006

1

					collator_account: 1,

5007

1

					total_exposed_amount: 50,

5008

1

},

5009

1

				Event::CollatorChosen {

5010

1

					round: 7,

5011

1

					collator_account: 3,

5012

1

					total_exposed_amount: 30,

5013

1

},

5014

1

				Event::CollatorChosen {

5015

1

					round: 7,

5016

1

					collator_account: 4,

5017

1

					total_exposed_amount: 30,

5018

1

},

5019

1

				Event::CollatorChosen {

5020

1

					round: 7,

5021

1

					collator_account: 5,

5022

1

					total_exposed_amount: 10,

5023

1

},

5024

1

				Event::NewRound {

5025

1

					starting_block: 30,

5026

1

					round: 7,

5027

1

					selected_collators_number: 4,

5028

1

					total_balance: 120,

5029

1

},

5030

);

5031

			// verify that delegations are removed after collator leaves, not before

5032

1

			assert_eq!(ParachainStaking::delegator_state(7).unwrap().total(), 90);

5033

1

			assert_eq!(

5034

1

				ParachainStaking::delegator_state(7)

5035

1

					.unwrap()

5036

1

					.delegations

5037

1

.0

5038

1

					.len(),

5039

				2usize

5040

);

5041

1

			assert_eq!(ParachainStaking::delegator_state(6).unwrap().total(), 40);

5042

1

			assert_eq!(

5043

1

				ParachainStaking::delegator_state(6)

5044

1

					.unwrap()

5045

1

					.delegations

5046

1

.0

5047

1

					.len(),

5048

				4usize

5049

);

5050

1

			assert_eq!(

5051

1

				query_freeze_amount(6, &FreezeReason::StakingDelegator.into()),

5052

5053

);

5054

1

			assert_eq!(

5055

1

				query_freeze_amount(7, &FreezeReason::StakingDelegator.into()),

5056

5057

);

5058

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&6), 60);

5059

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&7), 10);

5060

1

			roll_to_round_begin(8);

5061

1

			roll_blocks(1);

5062

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

5063

1

				RuntimeOrigin::signed(2),

5064

2,

5065

5066

));

5067

1

			assert_events_eq!(Event::CandidateLeft {

5068

1

				ex_candidate: 2,

5069

1

				unlocked_amount: 140,

5070

1

				new_total_amt_locked: 120,

5071

1

});

5072

1

			assert_eq!(ParachainStaking::delegator_state(7).unwrap().total(), 10);

5073

1

			assert_eq!(ParachainStaking::delegator_state(6).unwrap().total(), 30);

5074

1

			assert_eq!(

5075

1

				ParachainStaking::delegator_state(7)

5076

1

					.unwrap()

5077

1

					.delegations

5078

1

.0

5079

1

					.len(),

5080

				1usize

5081

);

5082

1

			assert_eq!(

5083

1

				ParachainStaking::delegator_state(6)

5084

1

					.unwrap()

5085

1

					.delegations

5086

1

.0

5087

1

					.len(),

5088

				3usize

5089

);

5090

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&6), 70);

5091

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&7), 90);

5092

1

});

5093

1

5094

5095

#[test]

5096

// The test verifies that the pending revoke request is removed by 2's exit so there is no dangling

5097

// revoke request after 2 exits

5098

1

fn execute_leave_candidate_removes_delegations() {

5099

1

	ExtBuilder::default()

5100

1

		.with_balances(vec![(1, 100), (2, 100), (3, 100), (4, 100)])

5101

1

		.with_candidates(vec![(1, 20), (2, 20)])

5102

1

		.with_delegations(vec![(3, 1, 10), (3, 2, 10), (4, 1, 10), (4, 2, 10)])

5103

1

		.build()

5104

1

		.execute_with(|| {

5105

			// Verifies the revocation request is initially empty

5106

1

			assert!(

5107

1

				ParachainStaking::delegation_scheduled_requests(&2, &3).is_empty(),

5108

				"no scheduled revoke request should exist before scheduling"

5109

);

5110

5111

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

5112

1

				RuntimeOrigin::signed(2),

5113

5114

));

5115

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

5116

1

				RuntimeOrigin::signed(3),

5117

5118

));

5119

			// Verifies the revocation request is present

5120

1

			assert!(

5121

1

				!ParachainStaking::delegation_scheduled_requests(&2, &3).is_empty(),

5122

				"a scheduled revoke request should exist after scheduling"

5123

);

5124

5125

1

			roll_to(16);

5126

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

5127

1

				RuntimeOrigin::signed(2),

5128

2,

5129

5130

));

5131

			// Verifies the revocation request is again empty

5132

1

			assert!(

5133

1

				ParachainStaking::delegation_scheduled_requests(&2, &3).is_empty(),

5134

				"scheduled revoke request should be removed when candidate leaves"

5135

);

5136

1

});

5137

1

5138

5139

#[test]

5140

1

fn payouts_follow_delegation_changes() {

5141

1

	ExtBuilder::default()

5142

1

		.with_balances(vec![

5143

1

			(1, 100),

5144

1

			(2, 100),

5145

1

			(3, 100),

5146

1

			(4, 100),

5147

1

			(6, 100),

5148

1

			(7, 100),

5149

1

			(8, 100),

5150

1

			(9, 100),

5151

1

			(10, 100),

5152

1

])

5153

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20), (4, 20)])

5154

1

		.with_delegations(vec![

5155

1

			(6, 1, 10),

5156

1

			(7, 1, 10),

5157

1

			(8, 2, 10),

5158

1

			(9, 2, 10),

5159

1

			(10, 1, 10),

5160

1

])

5161

1

		.build()

5162

1

		.execute_with(|| {

5163

			// ~ set block author as 1 for all blocks this round

5164

1

			set_author(1, 1, POINTS_PER_ROUND);

5165

1

			set_author(2, 1, POINTS_PER_ROUND);

5166

1

			roll_to_round_begin(2);

5167

			// chooses top TotalSelectedCandidates (5), in order

5168

1

			assert_events_eq!(

5169

1

				Event::CollatorChosen {

5170

1

					round: 2,

5171

1

					collator_account: 1,

5172

1

					total_exposed_amount: 50,

5173

1

},

5174

1

				Event::CollatorChosen {

5175

1

					round: 2,

5176

1

					collator_account: 2,

5177

1

					total_exposed_amount: 40,

5178

1

},

5179

1

				Event::CollatorChosen {

5180

1

					round: 2,

5181

1

					collator_account: 3,

5182

1

					total_exposed_amount: 20,

5183

1

},

5184

1

				Event::CollatorChosen {

5185

1

					round: 2,

5186

1

					collator_account: 4,

5187

1

					total_exposed_amount: 20,

5188

1

},

5189

1

				Event::NewRound {

5190

1

					starting_block: 5,

5191

1

					round: 2,

5192

1

					selected_collators_number: 4,

5193

1

					total_balance: 130,

5194

1

},

5195

);

5196

5197

1

			set_author(3, 1, POINTS_PER_ROUND);

5198

1

			set_author(4, 1, POINTS_PER_ROUND);

5199

5200

1

			roll_to_round_begin(4);

5201

			// distribute total issuance to collator 1 and its delegators 6, 7, 19

5202

1

			assert_events_eq!(

5203

1

				Event::CollatorChosen {

5204

1

					round: 4,

5205

1

					collator_account: 1,

5206

1

					total_exposed_amount: 50,

5207

1

},

5208

1

				Event::CollatorChosen {

5209

1

					round: 4,

5210

1

					collator_account: 2,

5211

1

					total_exposed_amount: 40,

5212

1

},

5213

1

				Event::CollatorChosen {

5214

1

					round: 4,

5215

1

					collator_account: 3,

5216

1

					total_exposed_amount: 20,

5217

1

},

5218

1

				Event::CollatorChosen {

5219

1

					round: 4,

5220

1

					collator_account: 4,

5221

1

					total_exposed_amount: 20,

5222

1

},

5223

1

				Event::NewRound {

5224

1

					starting_block: 15,

5225

1

					round: 4,

5226

1

					selected_collators_number: 4,

5227

1

					total_balance: 130,

5228

1

},

5229

);

5230

1

			roll_blocks(3);

5231

1

			assert_events_eq!(

5232

1

				Event::Rewarded {

5233

1

					account: 1,

5234

1

					rewards: 11,

5235

1

},

5236

1

				Event::Rewarded {

5237

1

					account: 6,

5238

1

					rewards: 4,

5239

1

},

5240

1

				Event::Rewarded {

5241

1

					account: 7,

5242

1

					rewards: 4,

5243

1

},

5244

1

				Event::Rewarded {

5245

1

					account: 10,

5246

1

					rewards: 4,

5247

1

},

5248

);

5249

			// ~ set block author as 1 for all blocks this round

5250

1

			set_author(5, 1, POINTS_PER_ROUND);

5251

5252

1

			roll_blocks(1);

5253

			// 1. ensure delegators are paid for 2 rounds after they leave

5254

1

			assert_noop!(

5255

1

				ParachainStaking::schedule_revoke_delegation(RuntimeOrigin::signed(66), 1),

5256

1

				Error::<Test>::DelegatorDNE

5257

);

5258

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

5259

1

				RuntimeOrigin::signed(6),

5260

1,

5261

));

5262

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

5263

1

				round: 4,

5264

1

				delegator: 6,

5265

1

				candidate: 1,

5266

1

				scheduled_exit: 6,

5267

1

});

5268

			// fast forward to block in which delegator 6 exit executes

5269

1

			roll_to_round_begin(5);

5270

1

			assert_events_eq!(

5271

1

				Event::CollatorChosen {

5272

1

					round: 5,

5273

1

					collator_account: 1,

5274

1

					total_exposed_amount: 50,

5275

1

},

5276

1

				Event::CollatorChosen {

5277

1

					round: 5,

5278

1

					collator_account: 2,

5279

1

					total_exposed_amount: 40,

5280

1

},

5281

1

				Event::CollatorChosen {

5282

1

					round: 5,

5283

1

					collator_account: 3,

5284

1

					total_exposed_amount: 20,

5285

1

},

5286

1

				Event::CollatorChosen {

5287

1

					round: 5,

5288

1

					collator_account: 4,

5289

1

					total_exposed_amount: 20,

5290

1

},

5291

1

				Event::NewRound {

5292

1

					starting_block: 20,

5293

1

					round: 5,

5294

1

					selected_collators_number: 4,

5295

1

					total_balance: 130,

5296

1

},

5297

);

5298

1

			roll_blocks(3);

5299

1

			assert_events_eq!(

5300

1

				Event::Rewarded {

5301

1

					account: 1,

5302

1

					rewards: 12,

5303

1

},

5304

1

				Event::Rewarded {

5305

1

					account: 6,

5306

1

					rewards: 4,

5307

1

},

5308

1

				Event::Rewarded {

5309

1

					account: 7,

5310

1

					rewards: 4,

5311

1

},

5312

1

				Event::Rewarded {

5313

1

					account: 10,

5314

1

					rewards: 4,

5315

1

},

5316

);

5317

5318

1

			set_author(6, 1, POINTS_PER_ROUND);

5319

			// keep paying 6 (note: inflation is in terms of total issuance so that's why 1 is 21)

5320

1

			roll_to_round_begin(6);

5321

1

			assert_ok!(ParachainStaking::execute_delegation_request(

5322

1

				RuntimeOrigin::signed(6),

5323

6,

5324

1,

5325

));

5326

1

			assert_events_eq!(

5327

1

				Event::CollatorChosen {

5328

1

					round: 6,

5329

1

					collator_account: 1,

5330

1

					total_exposed_amount: 50,

5331

1

},

5332

1

				Event::CollatorChosen {

5333

1

					round: 6,

5334

1

					collator_account: 2,

5335

1

					total_exposed_amount: 40,

5336

1

},

5337

1

				Event::CollatorChosen {

5338

1

					round: 6,

5339

1

					collator_account: 3,

5340

1

					total_exposed_amount: 20,

5341

1

},

5342

1

				Event::CollatorChosen {

5343

1

					round: 6,

5344

1

					collator_account: 4,

5345

1

					total_exposed_amount: 20,

5346

1

},

5347

1

				Event::NewRound {

5348

1

					starting_block: 25,

5349

1

					round: 6,

5350

1

					selected_collators_number: 4,

5351

1

					total_balance: 130,

5352

1

},

5353

1

				Event::DelegatorLeftCandidate {

5354

1

					delegator: 6,

5355

1

					candidate: 1,

5356

1

					unstaked_amount: 10,

5357

1

					total_candidate_staked: 40,

5358

1

},

5359

1

				Event::DelegationRevoked {

5360

1

					delegator: 6,

5361

1

					candidate: 1,

5362

1

					unstaked_amount: 10,

5363

1

},

5364

1

				Event::DelegatorLeft {

5365

1

					delegator: 6,

5366

1

					unstaked_amount: 10,

5367

1

},

5368

);

5369

1

			roll_blocks(3);

5370

1

			assert_events_eq!(

5371

1

				Event::Rewarded {

5372

1

					account: 1,

5373

1

					rewards: 12,

5374

1

},

5375

1

				Event::Rewarded {

5376

1

					account: 6,

5377

1

					rewards: 4,

5378

1

},

5379

1

				Event::Rewarded {

5380

1

					account: 7,

5381

1

					rewards: 4,

5382

1

},

5383

1

				Event::Rewarded {

5384

1

					account: 10,

5385

1

					rewards: 4,

5386

1

},

5387

);

5388

			// 6 won't be paid for this round because they left already

5389

1

			set_author(7, 1, POINTS_PER_ROUND);

5390

1

			roll_to_round_begin(7);

5391

			// keep paying 6

5392

1

			assert_events_eq!(

5393

1

				Event::CollatorChosen {

5394

1

					round: 7,

5395

1

					collator_account: 1,

5396

1

					total_exposed_amount: 40,

5397

1

},

5398

1

				Event::CollatorChosen {

5399

1

					round: 7,

5400

1

					collator_account: 2,

5401

1

					total_exposed_amount: 40,

5402

1

},

5403

1

				Event::CollatorChosen {

5404

1

					round: 7,

5405

1

					collator_account: 3,

5406

1

					total_exposed_amount: 20,

5407

1

},

5408

1

				Event::CollatorChosen {

5409

1

					round: 7,

5410

1

					collator_account: 4,

5411

1

					total_exposed_amount: 20,

5412

1

},

5413

1

				Event::NewRound {

5414

1

					starting_block: 30,

5415

1

					round: 7,

5416

1

					selected_collators_number: 4,

5417

1

					total_balance: 120,

5418

1

},

5419

);

5420

1

			roll_blocks(3);

5421

1

			assert_events_eq!(

5422

1

				Event::Rewarded {

5423

1

					account: 1,

5424

1

					rewards: 14,

5425

1

},

5426

1

				Event::Rewarded {

5427

1

					account: 7,

5428

1

					rewards: 5,

5429

1

},

5430

1

				Event::Rewarded {

5431

1

					account: 10,

5432

1

					rewards: 5,

5433

1

},

5434

);

5435

1

			set_author(8, 1, POINTS_PER_ROUND);

5436

1

			roll_to_round_begin(8);

5437

1

			assert_events_eq!(

5438

1

				Event::CollatorChosen {

5439

1

					round: 8,

5440

1

					collator_account: 1,

5441

1

					total_exposed_amount: 40,

5442

1

},

5443

1

				Event::CollatorChosen {

5444

1

					round: 8,

5445

1

					collator_account: 2,

5446

1

					total_exposed_amount: 40,

5447

1

},

5448

1

				Event::CollatorChosen {

5449

1

					round: 8,

5450

1

					collator_account: 3,

5451

1

					total_exposed_amount: 20,

5452

1

},

5453

1

				Event::CollatorChosen {

5454

1

					round: 8,

5455

1

					collator_account: 4,

5456

1

					total_exposed_amount: 20,

5457

1

},

5458

1

				Event::NewRound {

5459

1

					starting_block: 35,

5460

1

					round: 8,

5461

1

					selected_collators_number: 4,

5462

1

					total_balance: 120,

5463

1

},

5464

);

5465

1

			roll_blocks(3);

5466

1

			assert_events_eq!(

5467

1

				Event::Rewarded {

5468

1

					account: 1,

5469

1

					rewards: 15,

5470

1

},

5471

1

				Event::Rewarded {

5472

1

					account: 7,

5473

1

					rewards: 5,

5474

1

},

5475

1

				Event::Rewarded {

5476

1

					account: 10,

5477

1

					rewards: 5,

5478

1

},

5479

);

5480

1

			set_author(9, 1, POINTS_PER_ROUND);

5481

1

			roll_to_round_begin(9);

5482

			// no more paying 6

5483

1

			assert_events_eq!(

5484

1

				Event::CollatorChosen {

5485

1

					round: 9,

5486

1

					collator_account: 1,

5487

1

					total_exposed_amount: 40,

5488

1

},

5489

1

				Event::CollatorChosen {

5490

1

					round: 9,

5491

1

					collator_account: 2,

5492

1

					total_exposed_amount: 40,

5493

1

},

5494

1

				Event::CollatorChosen {

5495

1

					round: 9,

5496

1

					collator_account: 3,

5497

1

					total_exposed_amount: 20,

5498

1

},

5499

1

				Event::CollatorChosen {

5500

1

					round: 9,

5501

1

					collator_account: 4,

5502

1

					total_exposed_amount: 20,

5503

1

},

5504

1

				Event::NewRound {

5505

1

					starting_block: 40,

5506

1

					round: 9,

5507

1

					selected_collators_number: 4,

5508

1

					total_balance: 120,

5509

1

},

5510

);

5511

1

			roll_blocks(3);

5512

1

			assert_events_eq!(

5513

1

				Event::Rewarded {

5514

1

					account: 1,

5515

1

					rewards: 15,

5516

1

},

5517

1

				Event::Rewarded {

5518

1

					account: 7,

5519

1

					rewards: 5,

5520

1

},

5521

1

				Event::Rewarded {

5522

1

					account: 10,

5523

1

					rewards: 5,

5524

1

},

5525

);

5526

1

			roll_blocks(1);

5527

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5528

1

				RuntimeOrigin::signed(8),

5529

1,

5530

10,

5531

1

				Percent::zero(),

5532

10,

5533

0,

5534

5535

));

5536

1

			assert_events_eq!(Event::Delegation {

5537

1

				delegator: 8,

5538

1

				locked_amount: 10,

5539

1

				candidate: 1,

5540

1

				delegator_position: DelegatorAdded::AddedToTop { new_total: 50 },

5541

1

				auto_compound: Percent::zero(),

5542

1

});

5543

5544

1

			set_author(10, 1, POINTS_PER_ROUND);

5545

1

			roll_to_round_begin(10);

5546

			// new delegation is not rewarded yet

5547

1

			assert_events_eq!(

5548

1

				Event::CollatorChosen {

5549

1

					round: 10,

5550

1

					collator_account: 1,

5551

1

					total_exposed_amount: 50,

5552

1

},

5553

1

				Event::CollatorChosen {

5554

1

					round: 10,

5555

1

					collator_account: 2,

5556

1

					total_exposed_amount: 40,

5557

1

},

5558

1

				Event::CollatorChosen {

5559

1

					round: 10,

5560

1

					collator_account: 3,

5561

1

					total_exposed_amount: 20,

5562

1

},

5563

1

				Event::CollatorChosen {

5564

1

					round: 10,

5565

1

					collator_account: 4,

5566

1

					total_exposed_amount: 20,

5567

1

},

5568

1

				Event::NewRound {

5569

1

					starting_block: 45,

5570

1

					round: 10,

5571

1

					selected_collators_number: 4,

5572

1

					total_balance: 130,

5573

1

},

5574

);

5575

1

			roll_blocks(3);

5576

1

			assert_events_eq!(

5577

1

				Event::Rewarded {

5578

1

					account: 1,

5579

1

					rewards: 15,

5580

1

},

5581

1

				Event::Rewarded {

5582

1

					account: 7,

5583

1

					rewards: 5,

5584

1

},

5585

1

				Event::Rewarded {

5586

1

					account: 10,

5587

1

					rewards: 5,

5588

1

},

5589

);

5590

1

			roll_to_round_begin(11);

5591

			// new delegation not rewarded yet

5592

1

			assert_events_eq!(

5593

1

				Event::CollatorChosen {

5594

1

					round: 11,

5595

1

					collator_account: 1,

5596

1

					total_exposed_amount: 50,

5597

1

},

5598

1

				Event::CollatorChosen {

5599

1

					round: 11,

5600

1

					collator_account: 2,

5601

1

					total_exposed_amount: 40,

5602

1

},

5603

1

				Event::CollatorChosen {

5604

1

					round: 11,

5605

1

					collator_account: 3,

5606

1

					total_exposed_amount: 20,

5607

1

},

5608

1

				Event::CollatorChosen {

5609

1

					round: 11,

5610

1

					collator_account: 4,

5611

1

					total_exposed_amount: 20,

5612

1

},

5613

1

				Event::NewRound {

5614

1

					starting_block: 50,

5615

1

					round: 11,

5616

1

					selected_collators_number: 4,

5617

1

					total_balance: 130,

5618

1

},

5619

);

5620

1

			roll_blocks(3);

5621

1

			assert_events_eq!(

5622

1

				Event::Rewarded {

5623

1

					account: 1,

5624

1

					rewards: 15,

5625

1

},

5626

1

				Event::Rewarded {

5627

1

					account: 7,

5628

1

					rewards: 5,

5629

1

},

5630

1

				Event::Rewarded {

5631

1

					account: 10,

5632

1

					rewards: 5,

5633

1

},

5634

);

5635

1

			roll_to_round_begin(12);

5636

			// new delegation is rewarded for first time

5637

			// 2 rounds after joining (`RewardPaymentDelay` = 2)

5638

1

			assert_events_eq!(

5639

1

				Event::CollatorChosen {

5640

1

					round: 12,

5641

1

					collator_account: 1,

5642

1

					total_exposed_amount: 50,

5643

1

},

5644

1

				Event::CollatorChosen {

5645

1

					round: 12,

5646

1

					collator_account: 2,

5647

1

					total_exposed_amount: 40,

5648

1

},

5649

1

				Event::CollatorChosen {

5650

1

					round: 12,

5651

1

					collator_account: 3,

5652

1

					total_exposed_amount: 20,

5653

1

},

5654

1

				Event::CollatorChosen {

5655

1

					round: 12,

5656

1

					collator_account: 4,

5657

1

					total_exposed_amount: 20,

5658

1

},

5659

1

				Event::NewRound {

5660

1

					starting_block: 55,

5661

1

					round: 12,

5662

1

					selected_collators_number: 4,

5663

1

					total_balance: 130,

5664

1

},

5665

);

5666

1

			roll_blocks(3);

5667

1

			assert_events_eq!(

5668

1

				Event::Rewarded {

5669

1

					account: 1,

5670

1

					rewards: 14,

5671

1

},

5672

1

				Event::Rewarded {

5673

1

					account: 7,

5674

1

					rewards: 4,

5675

1

},

5676

1

				Event::Rewarded {

5677

1

					account: 10,

5678

1

					rewards: 4,

5679

1

},

5680

1

				Event::Rewarded {

5681

1

					account: 8,

5682

1

					rewards: 4,

5683

1

},

5684

);

5685

1

});

5686

1

5687

5688

#[test]

5689

1

fn bottom_delegations_are_empty_when_top_delegations_not_full() {

5690

1

	ExtBuilder::default()

5691

1

		.with_balances(vec![(1, 20), (2, 10), (3, 10), (4, 10), (5, 10)])

5692

1

		.with_candidates(vec![(1, 20)])

5693

1

		.build()

5694

1

		.execute_with(|| {

5695

			// no top delegators => no bottom delegators

5696

1

			let top_delegations = ParachainStaking::top_delegations(1).unwrap();

5697

1

			let bottom_delegations = ParachainStaking::bottom_delegations(1).unwrap();

5698

1

			assert!(top_delegations.delegations.is_empty());

5699

1

			assert!(bottom_delegations.delegations.is_empty());

5700

			// 1 delegator => 1 top delegator, 0 bottom delegators

5701

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5702

1

				RuntimeOrigin::signed(2),

5703

1,

5704

10,

5705

1

				Percent::zero(),

5706

10,

5707

0,

5708

5709

));

5710

1

			let top_delegations = ParachainStaking::top_delegations(1).unwrap();

5711

1

			let bottom_delegations = ParachainStaking::bottom_delegations(1).unwrap();

5712

1

			assert_eq!(top_delegations.delegations.len(), 1usize);

5713

1

			assert!(bottom_delegations.delegations.is_empty());

5714

			// 2 delegators => 2 top delegators, 0 bottom delegators

5715

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5716

1

				RuntimeOrigin::signed(3),

5717

1,

5718

10,

5719

1

				Percent::zero(),

5720

10,

5721

0,

5722

5723

));

5724

1

			let top_delegations = ParachainStaking::top_delegations(1).unwrap();

5725

1

			let bottom_delegations = ParachainStaking::bottom_delegations(1).unwrap();

5726

1

			assert_eq!(top_delegations.delegations.len(), 2usize);

5727

1

			assert!(bottom_delegations.delegations.is_empty());

5728

			// 3 delegators => 3 top delegators, 0 bottom delegators

5729

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5730

1

				RuntimeOrigin::signed(4),

5731

1,

5732

10,

5733

1

				Percent::zero(),

5734

10,

5735

0,

5736

5737

));

5738

1

			let top_delegations = ParachainStaking::top_delegations(1).unwrap();

5739

1

			let bottom_delegations = ParachainStaking::bottom_delegations(1).unwrap();

5740

1

			assert_eq!(top_delegations.delegations.len(), 3usize);

5741

1

			assert!(bottom_delegations.delegations.is_empty());

5742

			// 4 delegators => 4 top delegators, 0 bottom delegators

5743

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5744

1

				RuntimeOrigin::signed(5),

5745

1,

5746

10,

5747

1

				Percent::zero(),

5748

10,

5749

0,

5750

5751

));

5752

1

			let top_delegations = ParachainStaking::top_delegations(1).unwrap();

5753

1

			let bottom_delegations = ParachainStaking::bottom_delegations(1).unwrap();

5754

1

			assert_eq!(top_delegations.delegations.len(), 4usize);

5755

1

			assert!(bottom_delegations.delegations.is_empty());

5756

1

});

5757

1

5758

5759

#[test]

5760

1

fn candidate_pool_updates_when_total_counted_changes() {

5761

1

	ExtBuilder::default()

5762

1

		.with_balances(vec![

5763

1

			(1, 20),

5764

1

			(3, 19),

5765

1

			(4, 20),

5766

1

			(5, 21),

5767

1

			(6, 22),

5768

1

			(7, 15),

5769

1

			(8, 16),

5770

1

			(9, 17),

5771

1

			(10, 18),

5772

1

])

5773

1

		.with_candidates(vec![(1, 20)])

5774

1

		.with_delegations(vec![

5775

1

			(3, 1, 11),

5776

1

			(4, 1, 12),

5777

1

			(5, 1, 13),

5778

1

			(6, 1, 14),

5779

1

			(7, 1, 15),

5780

1

			(8, 1, 16),

5781

1

			(9, 1, 17),

5782

1

			(10, 1, 18),

5783

1

])

5784

1

		.build()

5785

1

		.execute_with(|| {

5786

5

			fn is_candidate_pool_bond(account: u64, bond: u128) {

5787

5

				let pool = ParachainStaking::candidate_pool();

5788

10

				for candidate in pool.0 {

5789

5

					if candidate.owner == account {

5790

5

						assert_eq!(

5791

							candidate.amount, bond,

5792

							"Candidate Bond {:?} is Not Equal to Expected: {:?}",

5793

							candidate.amount, bond

5794

);

5795

5796

5797

5

5798

			// 15 + 16 + 17 + 18 + 20 = 86 (top 4 + self bond)

5799

1

			is_candidate_pool_bond(1, 86);

5800

1

			assert_ok!(ParachainStaking::delegator_bond_more(

5801

1

				RuntimeOrigin::signed(3),

5802

1,

5803

5804

));

5805

			// 3: 11 -> 19 => 3 is in top, bumps out 7

5806

			// 16 + 17 + 18 + 19 + 20 = 90 (top 4 + self bond)

5807

1

			is_candidate_pool_bond(1, 90);

5808

1

			assert_ok!(ParachainStaking::delegator_bond_more(

5809

1

				RuntimeOrigin::signed(4),

5810

1,

5811

5812

));

5813

			// 4: 12 -> 20 => 4 is in top, bumps out 8

5814

			// 17 + 18 + 19 + 20 + 20 = 94 (top 4 + self bond)

5815

1

			is_candidate_pool_bond(1, 94);

5816

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

5817

1

				RuntimeOrigin::signed(10),

5818

1,

5819

5820

));

5821

1

			roll_to(30);

5822

			// 10: 18 -> 15 => 10 bumped to bottom, 8 bumped to top (- 18 + 16 = -2 for count)

5823

1

			assert_ok!(ParachainStaking::execute_delegation_request(

5824

1

				RuntimeOrigin::signed(10),

5825

10,

5826

5827

));

5828

			// 16 + 17 + 19 + 20 + 20 = 92 (top 4 + self bond)

5829

1

			is_candidate_pool_bond(1, 92);

5830

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

5831

1

				RuntimeOrigin::signed(9),

5832

1,

5833

5834

));

5835

1

			roll_to(40);

5836

1

			assert_ok!(ParachainStaking::execute_delegation_request(

5837

1

				RuntimeOrigin::signed(9),

5838

9,

5839

5840

));

5841

			// 15 + 16 + 19 + 20 + 20 = 90 (top 4 + self bond)

5842

1

			is_candidate_pool_bond(1, 90);

5843

1

});

5844

1

5845

5846

#[test]

5847

1

fn only_top_collators_are_counted() {

5848

1

	ExtBuilder::default()

5849

1

		.with_balances(vec![

5850

1

			(1, 20),

5851

1

			(3, 19),

5852

1

			(4, 20),

5853

1

			(5, 21),

5854

1

			(6, 22),

5855

1

			(7, 15),

5856

1

			(8, 16),

5857

1

			(9, 17),

5858

1

			(10, 18),

5859

1

])

5860

1

		.with_candidates(vec![(1, 20)])

5861

1

		.with_delegations(vec![

5862

1

			(3, 1, 11),

5863

1

			(4, 1, 12),

5864

1

			(5, 1, 13),

5865

1

			(6, 1, 14),

5866

1

			(7, 1, 15),

5867

1

			(8, 1, 16),

5868

1

			(9, 1, 17),

5869

1

			(10, 1, 18),

5870

1

])

5871

1

		.build()

5872

1

		.execute_with(|| {

5873

			// sanity check that 3-10 are delegators immediately

5874

9

			for i in 3..11 {

5875

8

				assert!(ParachainStaking::is_delegator(&i));

5876

5877

1

			let collator_state = ParachainStaking::candidate_info(1).unwrap();

5878

			// 15 + 16 + 17 + 18 + 20 = 86 (top 4 + self bond)

5879

1

			assert_eq!(collator_state.total_counted, 86);

5880

			// bump bottom to the top

5881

1

			assert_ok!(ParachainStaking::delegator_bond_more(

5882

1

				RuntimeOrigin::signed(3),

5883

1,

5884

5885

));

5886

1

			assert_events_emitted!(Event::DelegationIncreased {

5887

1

				delegator: 3,

5888

1

				candidate: 1,

5889

1

				amount: 8,

5890

1

				in_top: true,

5891

1

});

5892

1

			let collator_state = ParachainStaking::candidate_info(1).unwrap();

5893

			// 16 + 17 + 18 + 19 + 20 = 90 (top 4 + self bond)

5894

1

			assert_eq!(collator_state.total_counted, 90);

5895

			// bump bottom to the top

5896

1

			assert_ok!(ParachainStaking::delegator_bond_more(

5897

1

				RuntimeOrigin::signed(4),

5898

1,

5899

5900

));

5901

1

			assert_events_emitted!(Event::DelegationIncreased {

5902

1

				delegator: 4,

5903

1

				candidate: 1,

5904

1

				amount: 8,

5905

1

				in_top: true,

5906

1

});

5907

1

			let collator_state = ParachainStaking::candidate_info(1).unwrap();

5908

			// 17 + 18 + 19 + 20 + 20 = 94 (top 4 + self bond)

5909

1

			assert_eq!(collator_state.total_counted, 94);

5910

			// bump bottom to the top

5911

1

			assert_ok!(ParachainStaking::delegator_bond_more(

5912

1

				RuntimeOrigin::signed(5),

5913

1,

5914

5915

));

5916

1

			assert_events_emitted!(Event::DelegationIncreased {

5917

1

				delegator: 5,

5918

1

				candidate: 1,

5919

1

				amount: 8,

5920

1

				in_top: true,

5921

1

});

5922

1

			let collator_state = ParachainStaking::candidate_info(1).unwrap();

5923

			// 18 + 19 + 20 + 21 + 20 = 98 (top 4 + self bond)

5924

1

			assert_eq!(collator_state.total_counted, 98);

5925

			// bump bottom to the top

5926

1

			assert_ok!(ParachainStaking::delegator_bond_more(

5927

1

				RuntimeOrigin::signed(6),

5928

1,

5929

5930

));

5931

1

			assert_events_emitted!(Event::DelegationIncreased {

5932

1

				delegator: 6,

5933

1

				candidate: 1,

5934

1

				amount: 8,

5935

1

				in_top: true,

5936

1

});

5937

1

			let collator_state = ParachainStaking::candidate_info(1).unwrap();

5938

			// 19 + 20 + 21 + 22 + 20 = 102 (top 4 + self bond)

5939

1

			assert_eq!(collator_state.total_counted, 102);

5940

1

});

5941

1

5942

5943

#[test]

5944

1

fn delegation_events_convey_correct_position() {

5945

1

	ExtBuilder::default()

5946

1

		.with_balances(vec![

5947

1

			(1, 100),

5948

1

			(2, 100),

5949

1

			(3, 100),

5950

1

			(4, 100),

5951

1

			(5, 100),

5952

1

			(6, 100),

5953

1

			(7, 100),

5954

1

			(8, 100),

5955

1

			(9, 100),

5956

1

			(10, 100),

5957

1

])

5958

1

		.with_candidates(vec![(1, 20), (2, 20)])

5959

1

		.with_delegations(vec![(3, 1, 11), (4, 1, 12), (5, 1, 13), (6, 1, 14)])

5960

1

		.build()

5961

1

		.execute_with(|| {

5962

1

			let collator1_state = ParachainStaking::candidate_info(1).unwrap();

5963

			// 11 + 12 + 13 + 14 + 20 = 70 (top 4 + self bond)

5964

1

			assert_eq!(collator1_state.total_counted, 70);

5965

			// Top delegations are full, new highest delegation is made

5966

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5967

1

				RuntimeOrigin::signed(7),

5968

1,

5969

15,

5970

1

				Percent::zero(),

5971

10,

5972

0,

5973

5974

));

5975

1

			assert_events_emitted!(Event::Delegation {

5976

1

				delegator: 7,

5977

1

				locked_amount: 15,

5978

1

				candidate: 1,

5979

1

				delegator_position: DelegatorAdded::AddedToTop { new_total: 74 },

5980

1

				auto_compound: Percent::zero(),

5981

1

});

5982

1

			let collator1_state = ParachainStaking::candidate_info(1).unwrap();

5983

			// 12 + 13 + 14 + 15 + 20 = 70 (top 4 + self bond)

5984

1

			assert_eq!(collator1_state.total_counted, 74);

5985

			// New delegation is added to the bottom

5986

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5987

1

				RuntimeOrigin::signed(8),

5988

1,

5989

10,

5990

1

				Percent::zero(),

5991

10,

5992

0,

5993

5994

));

5995

1

			assert_events_emitted!(Event::Delegation {

5996

1

				delegator: 8,

5997

1

				locked_amount: 10,

5998

1

				candidate: 1,

5999

1

				delegator_position: DelegatorAdded::AddedToBottom,

6000

1

				auto_compound: Percent::zero(),

6001

1

});

6002

1

			let collator1_state = ParachainStaking::candidate_info(1).unwrap();

6003

			// 12 + 13 + 14 + 15 + 20 = 70 (top 4 + self bond)

6004

1

			assert_eq!(collator1_state.total_counted, 74);

6005

			// 8 increases delegation to the top

6006

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6007

1

				RuntimeOrigin::signed(8),

6008

1,

6009

6010

));

6011

1

			assert_events_emitted!(Event::DelegationIncreased {

6012

1

				delegator: 8,

6013

1

				candidate: 1,

6014

1

				amount: 3,

6015

1

				in_top: true,

6016

1

});

6017

1

			let collator1_state = ParachainStaking::candidate_info(1).unwrap();

6018

			// 13 + 13 + 14 + 15 + 20 = 75 (top 4 + self bond)

6019

1

			assert_eq!(collator1_state.total_counted, 75);

6020

			// 3 increases delegation but stays in bottom

6021

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6022

1

				RuntimeOrigin::signed(3),

6023

1,

6024

6025

));

6026

1

			assert_events_emitted!(Event::DelegationIncreased {

6027

1

				delegator: 3,

6028

1

				candidate: 1,

6029

1

				amount: 1,

6030

1

				in_top: false,

6031

1

});

6032

1

			let collator1_state = ParachainStaking::candidate_info(1).unwrap();

6033

			// 13 + 13 + 14 + 15 + 20 = 75 (top 4 + self bond)

6034

1

			assert_eq!(collator1_state.total_counted, 75);

6035

			// 6 decreases delegation but stays in top

6036

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

6037

1

				RuntimeOrigin::signed(6),

6038

1,

6039

6040

));

6041

1

			assert_events_emitted!(Event::DelegationDecreaseScheduled {

6042

1

				delegator: 6,

6043

1

				candidate: 1,

6044

1

				amount_to_decrease: 2,

6045

1

				execute_round: 3,

6046

1

});

6047

1

			roll_to(30);

6048

1

			assert_ok!(ParachainStaking::execute_delegation_request(

6049

1

				RuntimeOrigin::signed(6),

6050

6,

6051

6052

));

6053

1

			assert_events_emitted!(Event::DelegationDecreased {

6054

1

				delegator: 6,

6055

1

				candidate: 1,

6056

1

				amount: 2,

6057

1

				in_top: true,

6058

1

});

6059

1

			let collator1_state = ParachainStaking::candidate_info(1).unwrap();

6060

			// 12 + 13 + 13 + 15 + 20 = 73 (top 4 + self bond)ƒ

6061

1

			assert_eq!(collator1_state.total_counted, 73);

6062

			// 6 decreases delegation and is bumped to bottom

6063

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

6064

1

				RuntimeOrigin::signed(6),

6065

1,

6066

6067

));

6068

1

			assert_events_emitted!(Event::DelegationDecreaseScheduled {

6069

1

				delegator: 6,

6070

1

				candidate: 1,

6071

1

				amount_to_decrease: 1,

6072

1

				execute_round: 9,

6073

1

});

6074

1

			roll_to(40);

6075

1

			assert_ok!(ParachainStaking::execute_delegation_request(

6076

1

				RuntimeOrigin::signed(6),

6077

6,

6078

6079

));

6080

1

			assert_events_emitted!(Event::DelegationDecreased {

6081

1

				delegator: 6,

6082

1

				candidate: 1,

6083

1

				amount: 1,

6084

1

				in_top: false,

6085

1

});

6086

1

			let collator1_state = ParachainStaking::candidate_info(1).unwrap();

6087

			// 12 + 13 + 13 + 15 + 20 = 73 (top 4 + self bond)

6088

1

			assert_eq!(collator1_state.total_counted, 73);

6089

1

});

6090

1

6091

6092

#[test]

6093

1

fn no_rewards_paid_until_after_reward_payment_delay() {

6094

1

	ExtBuilder::default()

6095

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20)])

6096

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20)])

6097

1

		.build()

6098

1

		.execute_with(|| {

6099

			// payouts for round 1

6100

1

			set_author(1, 1, POINTS_PER_BLOCK);

6101

1

			set_author(1, 2, POINTS_PER_BLOCK * 2);

6102

1

			set_author(1, 3, POINTS_PER_BLOCK * 2);

6103

6104

1

			roll_to_round_begin(2);

6105

1

			assert_events_eq!(

6106

1

				Event::CollatorChosen {

6107

1

					round: 2,

6108

1

					collator_account: 1,

6109

1

					total_exposed_amount: 20,

6110

1

},

6111

1

				Event::CollatorChosen {

6112

1

					round: 2,

6113

1

					collator_account: 2,

6114

1

					total_exposed_amount: 20,

6115

1

},

6116

1

				Event::CollatorChosen {

6117

1

					round: 2,

6118

1

					collator_account: 3,

6119

1

					total_exposed_amount: 20,

6120

1

},

6121

1

				Event::NewRound {

6122

1

					starting_block: 5,

6123

1

					round: 2,

6124

1

					selected_collators_number: 3,

6125

1

					total_balance: 60,

6126

1

},

6127

);

6128

6129

1

			roll_to_round_begin(3);

6130

1

			assert_events_eq!(

6131

1

				Event::CollatorChosen {

6132

1

					round: 3,

6133

1

					collator_account: 1,

6134

1

					total_exposed_amount: 20,

6135

1

},

6136

1

				Event::CollatorChosen {

6137

1

					round: 3,

6138

1

					collator_account: 2,

6139

1

					total_exposed_amount: 20,

6140

1

},

6141

1

				Event::CollatorChosen {

6142

1

					round: 3,

6143

1

					collator_account: 3,

6144

1

					total_exposed_amount: 20,

6145

1

},

6146

1

				Event::NewRound {

6147

1

					starting_block: 10,

6148

1

					round: 3,

6149

1

					selected_collators_number: 3,

6150

1

					total_balance: 60,

6151

1

},

6152

);

6153

6154

1

			roll_blocks(1);

6155

1

			assert_events_eq!(Event::Rewarded {

6156

1

				account: 3,

6157

1

				rewards: 1,

6158

1

});

6159

6160

1

			roll_blocks(1);

6161

1

			assert_events_eq!(Event::Rewarded {

6162

1

				account: 1,

6163

1

				rewards: 0,

6164

1

});

6165

6166

1

			roll_blocks(1);

6167

1

			assert_events_eq!(Event::Rewarded {

6168

1

				account: 2,

6169

1

				rewards: 1,

6170

1

});

6171

6172

			// there should be no more payments in this round...

6173

1

			let num_blocks_rolled = roll_to_round_end(3);

6174

1

			assert_no_events!();

6175

1

			assert_eq!(num_blocks_rolled, 1);

6176

1

});

6177

1

6178

6179

#[test]

6180

1

fn deferred_payment_storage_items_are_cleaned_up() {

6181

	use crate::*;

6182

6183

	// this test sets up two collators, gives them points in round one, and focuses on the

6184

	// storage over the next several blocks to show that it is properly cleaned up

6185

6186

1

	ExtBuilder::default()

6187

1

		.with_balances(vec![(1, 20), (2, 20)])

6188

1

		.with_candidates(vec![(1, 20), (2, 20)])

6189

1

		.build()

6190

1

		.execute_with(|| {

6191

1

			set_author(1, 1, POINTS_PER_BLOCK * 3);

6192

1

			set_author(1, 2, POINTS_PER_BLOCK * 2);

6193

6194

			// reflects genesis?

6195

1

			assert!(<AtStake<Test>>::contains_key(1, 1));

6196

1

			assert!(<AtStake<Test>>::contains_key(1, 2));

6197

6198

1

			roll_to_round_begin(2);

6199

1

			assert_events_eq!(

6200

1

				Event::CollatorChosen {

6201

1

					round: 2,

6202

1

					collator_account: 1,

6203

1

					total_exposed_amount: 20,

6204

1

},

6205

1

				Event::CollatorChosen {

6206

1

					round: 2,

6207

1

					collator_account: 2,

6208

1

					total_exposed_amount: 20,

6209

1

},

6210

1

				Event::NewRound {

6211

1

					starting_block: 5,

6212

1

					round: 2,

6213

1

					selected_collators_number: 2,

6214

1

					total_balance: 40,

6215

1

},

6216

);

6217

6218

			// we should have AtStake snapshots as soon as we start a round...

6219

1

			assert!(<AtStake<Test>>::contains_key(2, 1));

6220

1

			assert!(<AtStake<Test>>::contains_key(2, 2));

6221

			// ...and it should persist until the round is fully paid out

6222

1

			assert!(<AtStake<Test>>::contains_key(1, 1));

6223

1

			assert!(<AtStake<Test>>::contains_key(1, 2));

6224

6225

1

			assert!(

6226

1

				<Points<Test>>::contains_key(1),

6227

				"Points should be populated during current round"

6228

);

6229

6230

1

			assert!(

6231

1

				!<Points<Test>>::contains_key(2),

6232

				"Points should not be populated until author noted"

6233

);

6234

6235

			// first payout occurs in round 3

6236

1

			roll_to_round_begin(3);

6237

1

			assert_events_eq!(

6238

1

				Event::CollatorChosen {

6239

1

					round: 3,

6240

1

					collator_account: 1,

6241

1

					total_exposed_amount: 20,

6242

1

},

6243

1

				Event::CollatorChosen {

6244

1

					round: 3,

6245

1

					collator_account: 2,

6246

1

					total_exposed_amount: 20,

6247

1

},

6248

1

				Event::NewRound {

6249

1

					starting_block: 10,

6250

1

					round: 3,

6251

1

					selected_collators_number: 2,

6252

1

					total_balance: 40,

6253

1

},

6254

);

6255

6256

1

			roll_blocks(1);

6257

1

			assert_events_eq!(Event::Rewarded {

6258

1

				account: 1,

6259

1

				rewards: 1,

6260

1

			},);

6261

6262

			// payouts should exist for past rounds that haven't been paid out yet..

6263

1

			assert!(<AtStake<Test>>::contains_key(3, 1));

6264

1

			assert!(<AtStake<Test>>::contains_key(3, 2));

6265

1

			assert!(<AtStake<Test>>::contains_key(2, 1));

6266

1

			assert!(<AtStake<Test>>::contains_key(2, 2));

6267

6268

1

			assert!(

6269

1

				<DelayedPayouts<Test>>::contains_key(1),

6270

				"DelayedPayouts should be populated after RewardPaymentDelay"

6271

);

6272

1

			assert!(<Points<Test>>::contains_key(1));

6273

1

			assert!(<DelayedPayouts<Test>>::contains_key(2));

6274

1

			assert!(

6275

1

				<Points<Test>>::contains_key(2),

6276

				"We awarded points for round 2"

6277

);

6278

6279

1

			assert!(!<DelayedPayouts<Test>>::contains_key(3));

6280

1

			assert!(

6281

1

				<Points<Test>>::contains_key(3),

6282

				"We awarded points for round 3"

6283

);

6284

6285

			// collator 1 has been paid in this last block and associated storage cleaned up

6286

1

			assert!(!<AtStake<Test>>::contains_key(1, 1));

6287

1

			assert!(!<AwardedPts<Test>>::contains_key(1, 1));

6288

6289

			// but collator 2 hasn't been paid

6290

1

			assert!(<AtStake<Test>>::contains_key(1, 2));

6291

1

			assert!(<AwardedPts<Test>>::contains_key(1, 2));

6292

6293

			// second payout occurs in next block

6294

1

			roll_blocks(1);

6295

1

			assert_events_eq!(Event::Rewarded {

6296

1

				account: 2,

6297

1

				rewards: 0,

6298

1

			},);

6299

6300

1

			roll_to_round_begin(4);

6301

1

			assert_events_eq!(

6302

1

				Event::CollatorChosen {

6303

1

					round: 4,

6304

1

					collator_account: 1,

6305

1

					total_exposed_amount: 20,

6306

1

},

6307

1

				Event::CollatorChosen {

6308

1

					round: 4,

6309

1

					collator_account: 2,

6310

1

					total_exposed_amount: 20,

6311

1

},

6312

1

				Event::NewRound {

6313

1

					starting_block: 15,

6314

1

					round: 4,

6315

1

					selected_collators_number: 2,

6316

1

					total_balance: 40,

6317

1

},

6318

);

6319

6320

			// collators have both been paid and storage fully cleaned up for round 1

6321

1

			assert!(!<AtStake<Test>>::contains_key(1, 2));

6322

1

			assert!(!<AwardedPts<Test>>::contains_key(1, 2));

6323

1

			assert!(!<Points<Test>>::contains_key(1)); // points should be cleaned up

6324

1

			assert!(!<DelayedPayouts<Test>>::contains_key(1));

6325

6326

1

			roll_to_round_end(4);

6327

6328

			// no more events expected

6329

1

			assert_no_events!();

6330

1

});

6331

1

6332

6333

#[test]

6334

1

fn deferred_payment_and_at_stake_storage_items_cleaned_up_for_candidates_not_producing_blocks() {

6335

	use crate::*;

6336

6337

1

	ExtBuilder::default()

6338

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20)])

6339

1

		.with_candidates(vec![(1, 20), (2, 20), (3, 20)])

6340

1

		.build()

6341

1

		.execute_with(|| {

6342

			// candidate 3 will not produce blocks

6343

1

			set_author(1, 1, POINTS_PER_BLOCK * 3);

6344

1

			set_author(1, 2, POINTS_PER_BLOCK * 2);

6345

6346

			// reflects genesis?

6347

1

			assert!(<AtStake<Test>>::contains_key(1, 1));

6348

1

			assert!(<AtStake<Test>>::contains_key(1, 2));

6349

6350

1

			roll_to_round_begin(2);

6351

1

			assert!(<AtStake<Test>>::contains_key(1, 1));

6352

1

			assert!(<AtStake<Test>>::contains_key(1, 2));

6353

1

			assert!(<AtStake<Test>>::contains_key(1, 3));

6354

1

			assert!(<AwardedPts<Test>>::contains_key(1, 1));

6355

1

			assert!(<AwardedPts<Test>>::contains_key(1, 2));

6356

1

			assert!(!<AwardedPts<Test>>::contains_key(1, 3));

6357

1

			assert!(<Points<Test>>::contains_key(1));

6358

1

			roll_to_round_begin(3);

6359

1

			assert!(<DelayedPayouts<Test>>::contains_key(1));

6360

6361

			// all storage items must be cleaned up

6362

1

			roll_to_round_begin(4);

6363

1

			assert!(!<AtStake<Test>>::contains_key(1, 1));

6364

1

			assert!(!<AtStake<Test>>::contains_key(1, 2));

6365

1

			assert!(!<AtStake<Test>>::contains_key(1, 3));

6366

1

			assert!(!<AwardedPts<Test>>::contains_key(1, 1));

6367

1

			assert!(!<AwardedPts<Test>>::contains_key(1, 2));

6368

1

			assert!(!<AwardedPts<Test>>::contains_key(1, 3));

6369

1

			assert!(!<Points<Test>>::contains_key(1));

6370

1

			assert!(!<DelayedPayouts<Test>>::contains_key(1));

6371

1

});

6372

1

6373

6374

#[test]

6375

1

fn deferred_payment_steady_state_event_flow() {

6376

	// this test "flows" through a number of rounds, asserting that certain things do/don't happen

6377

	// once the staking pallet is in a "steady state" (specifically, once we are past the first few

6378

	// rounds to clear RewardPaymentDelay)

6379

	use crate::mock::System;

6380

6381

1

	ExtBuilder::default()

6382

1

		.with_balances(vec![

6383

1

			// collators

6384

1

			(1, 200),

6385

1

			(2, 200),

6386

1

			(3, 200),

6387

1

			(4, 200),

6388

1

			// delegators

6389

1

			(11, 200),

6390

1

			(22, 200),

6391

1

			(33, 200),

6392

1

			(44, 200),

6393

1

			// burn account, see `reset_issuance()`

6394

1

			(111, 1000),

6395

1

])

6396

1

		.with_candidates(vec![(1, 200), (2, 200), (3, 200), (4, 200)])

6397

1

		.with_delegations(vec![

6398

1

			// delegator 11 delegates 100 to 1 and 2

6399

1

			(11, 1, 100),

6400

1

			(11, 2, 100),

6401

1

			// delegator 22 delegates 100 to 2 and 3

6402

1

			(22, 2, 100),

6403

1

			(22, 3, 100),

6404

1

			// delegator 33 delegates 100 to 3 and 4

6405

1

			(33, 3, 100),

6406

1

			(33, 4, 100),

6407

1

			// delegator 44 delegates 100 to 4 and 1

6408

1

			(44, 4, 100),

6409

1

			(44, 1, 100),

6410

1

])

6411

1

		.build()

6412

1

		.execute_with(|| {

6413

			// convenience to set the round points consistently

6414

3

			let set_round_points = |round: BlockNumber| {

6415

3

				set_author(round as BlockNumber, 1, 2 * POINTS_PER_ROUND);

6416

3

				set_author(round as BlockNumber, 2, POINTS_PER_ROUND);

6417

3

				set_author(round as BlockNumber, 3, POINTS_PER_ROUND);

6418

3

				set_author(round as BlockNumber, 4, POINTS_PER_ROUND);

6419

3

};

6420

6421

			// grab initial issuance -- we will reset it before round issuance is calculated so that

6422

			// it is consistent every round

6423

1

			let account: AccountId = 111;

6424

1

			let initial_issuance = Balances::total_issuance();

6425

2

			let reset_issuance = || {

6426

2

				let new_issuance = Balances::total_issuance();

6427

2

				let amount_to_burn = new_issuance - initial_issuance;

6428

2

				let _ = Balances::burn(Some(account).into(), amount_to_burn, false);

6429

2

				System::assert_last_event(RuntimeEvent::Balances(BalancesEvent::Burned {

6430

2

					who: account,

6431

2

					amount: amount_to_burn,

6432

2

				}));

6433

2

				Balances::settle(

6434

2

					&account,

6435

2

					PositiveImbalance::new(amount_to_burn),

6436

					WithdrawReasons::FEE,

6437

2

					ExistenceRequirement::AllowDeath,

6438

6439

2

				.expect("Account can absorb burn");

6440

2

};

6441

6442

			// fn to roll through the first RewardPaymentDelay rounds. returns new round index

6443

1

			let roll_through_initial_rounds = |mut round: BlockNumber| -> BlockNumber {

6444

3

				while round < crate::mock::RewardPaymentDelay::get() + 1 {

6445

2

					set_round_points(round);

6446

2

6447

2

					roll_to_round_end(round);

6448

2

					round += 1;

6449

2

6450

1

				reset_issuance();

6451

6452

1

				round

6453

1

};

6454

6455

			// roll through a "steady state" round and make all of our assertions

6456

			// returns new round index

6457

1

			let roll_through_steady_state_round = |round: BlockNumber| -> BlockNumber {

6458

1

				let num_rounds_rolled = roll_to_round_begin(round);

6459

1

				assert!(

6460

1

					num_rounds_rolled <= 1,

6461

					"expected to be at round begin already"

6462

);

6463

6464

1

				assert_events_eq!(

6465

1

					Event::CollatorChosen {

6466

1

						round: round as u32,

6467

1

						collator_account: 1,

6468

1

						total_exposed_amount: 400,

6469

1

},

6470

1

					Event::CollatorChosen {

6471

1

						round: round as u32,

6472

1

						collator_account: 2,

6473

1

						total_exposed_amount: 400,

6474

1

},

6475

1

					Event::CollatorChosen {

6476

1

						round: round as u32,

6477

1

						collator_account: 3,

6478

1

						total_exposed_amount: 400,

6479

1

},

6480

1

					Event::CollatorChosen {

6481

1

						round: round as u32,

6482

1

						collator_account: 4,

6483

1

						total_exposed_amount: 400,

6484

1

},

6485

1

					Event::NewRound {

6486

1

						starting_block: (round as u32 - 1) * 5,

6487

1

						round: round as u32,

6488

1

						selected_collators_number: 4,

6489

1

						total_balance: 1600,

6490

1

},

6491

);

6492

6493

1

				set_round_points(round);

6494

6495

1

				roll_blocks(1);

6496

1

				assert_events_eq!(

6497

1

					Event::Rewarded {

6498

1

						account: 3,

6499

1

						rewards: 13,

6500

1

},

6501

1

					Event::Rewarded {

6502

1

						account: 22,

6503

1

						rewards: 4,

6504

1

},

6505

1

					Event::Rewarded {

6506

1

						account: 33,

6507

1

						rewards: 4,

6508

1

},

6509

);

6510

6511

1

				roll_blocks(1);

6512

1

				assert_events_eq!(

6513

1

					Event::Rewarded {

6514

1

						account: 4,

6515

1

						rewards: 13,

6516

1

},

6517

1

					Event::Rewarded {

6518

1

						account: 33,

6519

1

						rewards: 4,

6520

1

},

6521

1

					Event::Rewarded {

6522

1

						account: 44,

6523

1

						rewards: 4,

6524

1

},

6525

);

6526

6527

1

				roll_blocks(1);

6528

1

				assert_events_eq!(

6529

1

					Event::Rewarded {

6530

1

						account: 1,

6531

1

						rewards: 27,

6532

1

},

6533

1

					Event::Rewarded {

6534

1

						account: 11,

6535

1

						rewards: 9,

6536

1

},

6537

1

					Event::Rewarded {

6538

1

						account: 44,

6539

1

						rewards: 9,

6540

1

},

6541

);

6542

6543

1

				roll_blocks(1);

6544

1

				assert_events_eq!(

6545

1

					Event::Rewarded {

6546

1

						account: 2,

6547

1

						rewards: 13,

6548

1

},

6549

1

					Event::Rewarded {

6550

1

						account: 11,

6551

1

						rewards: 4,

6552

1

},

6553

1

					Event::Rewarded {

6554

1

						account: 22,

6555

1

						rewards: 4,

6556

1

},

6557

);

6558

6559

1

				roll_blocks(1);

6560

				// Since we defer first deferred staking payout, this test have the maximum amout of

6561

				// supported collators. This eman that the next round is trigerred one block after

6562

				// the last reward.

6563

				//assert_no_events!();

6564

6565

1

				let num_rounds_rolled = roll_to_round_end(round);

6566

1

				assert_eq!(num_rounds_rolled, 0, "expected to be at round end already");

6567

6568

1

				reset_issuance();

6569

6570

1

				round + 1

6571

1

};

6572

6573

1

			let mut round = 1;

6574

1

			round = roll_through_initial_rounds(round); // we should be at RewardPaymentDelay

6575

2

			for _ in 1..2 {

6576

1

				round = roll_through_steady_state_round(round);

6577

1

6578

1

});

6579

1

6580

6581

#[test]

6582

1

fn delegation_kicked_from_bottom_removes_pending_request() {

6583

1

	ExtBuilder::default()

6584

1

		.with_balances(vec![

6585

1

			(1, 30),

6586

1

			(2, 29),

6587

1

			(3, 20),

6588

1

			(4, 20),

6589

1

			(5, 20),

6590

1

			(6, 20),

6591

1

			(7, 20),

6592

1

			(8, 20),

6593

1

			(9, 20),

6594

1

			(10, 20),

6595

1

			(11, 30),

6596

1

])

6597

1

		.with_candidates(vec![(1, 30), (11, 30)])

6598

1

		.with_delegations(vec![

6599

1

			(2, 1, 19),

6600

1

			(2, 11, 10), // second delegation so not left after first is kicked

6601

1

			(3, 1, 20),

6602

1

			(4, 1, 20),

6603

1

			(5, 1, 20),

6604

1

			(6, 1, 20),

6605

1

			(7, 1, 20),

6606

1

			(8, 1, 20),

6607

1

			(9, 1, 20),

6608

1

])

6609

1

		.build()

6610

1

		.execute_with(|| {

6611

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

6612

1

				RuntimeOrigin::signed(2),

6613

6614

));

6615

			// 10 delegates to full 1 => kicks lowest delegation (2, 19)

6616

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

6617

1

				RuntimeOrigin::signed(10),

6618

1,

6619

20,

6620

1

				Percent::zero(),

6621

8,

6622

0,

6623

0,

6624

));

6625

			// check the event

6626

1

			assert_events_emitted!(Event::DelegationKicked {

6627

1

				delegator: 2,

6628

1

				candidate: 1,

6629

1

				unstaked_amount: 19,

6630

1

});

6631

			// ensure request DNE

6632

1

			assert!(

6633

1

				ParachainStaking::delegation_scheduled_requests(&1, &2).is_empty(),

6634

				"delegation request should be removed when delegation is kicked"

6635

);

6636

1

});

6637

1

6638

6639

#[test]

6640

1

fn no_selected_candidates_defaults_to_last_round_collators() {

6641

1

	ExtBuilder::default()

6642

1

		.with_balances(vec![(1, 30), (2, 30), (3, 30), (4, 30), (5, 30)])

6643

1

		.with_candidates(vec![(1, 30), (2, 30), (3, 30), (4, 30), (5, 30)])

6644

1

		.build()

6645

1

		.execute_with(|| {

6646

1

			roll_to_round_begin(1);

6647

			// schedule to leave

6648

6

			for i in 1..6 {

6649

5

				assert_ok!(ParachainStaking::schedule_leave_candidates(

6650

5

					RuntimeOrigin::signed(i),

6651

6652

));

6653

6654

1

			let old_round = ParachainStaking::round().current;

6655

1

			let old_selected_candidates = ParachainStaking::selected_candidates();

6656

1

			let mut old_at_stake_snapshots = Vec::new();

6657

5

			for account in old_selected_candidates.clone() {

6658

5

				old_at_stake_snapshots.push(<AtStake<Test>>::get(old_round, account));

6659

5

6660

1

			roll_to_round_begin(3);

6661

			// execute leave

6662

6

			for i in 1..6 {

6663

5

				assert_ok!(ParachainStaking::execute_leave_candidates(

6664

5

					RuntimeOrigin::signed(i),

6665

5

i,

6666

0,

6667

));

6668

6669

			// next round

6670

1

			roll_to_round_begin(4);

6671

1

			let new_round = ParachainStaking::round().current;

6672

			// check AtStake matches previous

6673

1

			let new_selected_candidates = ParachainStaking::selected_candidates();

6674

1

			assert_eq!(old_selected_candidates, new_selected_candidates);

6675

1

			let mut index = 0usize;

6676

6

			for account in new_selected_candidates {

6677

5

				assert_eq!(

6678

5

					old_at_stake_snapshots[index],

6679

5

					<AtStake<Test>>::get(new_round, account)

6680

);

6681

5

				index += 1usize;

6682

6683

1

});

6684

1

6685

6686

#[test]

6687

1

fn test_delegator_scheduled_for_revoke_is_rewarded_for_previous_rounds_but_not_for_future() {

6688

1

	ExtBuilder::default()

6689

1

		.with_balances(vec![(1, 20), (2, 40), (3, 20), (4, 20)])

6690

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20)])

6691

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

6692

1

		.build()

6693

1

		.execute_with(|| {

6694

			// preset rewards for rounds 1, 2 and 3

6695

3

			(1..=3).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

6696

6697

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

6698

1

				RuntimeOrigin::signed(2),

6699

6700

));

6701

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

6702

1

				round: 1,

6703

1

				delegator: 2,

6704

1

				candidate: 1,

6705

1

				scheduled_exit: 3,

6706

1

});

6707

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

6708

1

			assert_eq!(

6709

				1, collator.delegation_count,

6710

				"collator's delegator count was reduced unexpectedly"

6711

);

6712

1

			assert_eq!(

6713

				30, collator.total_counted,

6714

				"collator's total was reduced unexpectedly"

6715

);

6716

6717

1

			roll_to_round_begin(3);

6718

1

			assert_events_emitted_match!(Event::NewRound { round: 3, .. });

6719

1

			roll_blocks(3);

6720

1

			assert_events_eq!(

6721

1

				Event::Rewarded {

6722

1

					account: 1,

6723

1

					rewards: 2,

6724

1

},

6725

1

				Event::Rewarded {

6726

1

					account: 2,

6727

1

					rewards: 1,

6728

1

},

6729

);

6730

6731

1

			roll_to_round_begin(4);

6732

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

6733

1

			roll_blocks(3);

6734

1

			assert_events_eq!(Event::Rewarded {

6735

1

				account: 1,

6736

1

				rewards: 2,

6737

1

			},);

6738

1

			let collator_snapshot =

6739

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

6740

1

					.unwrap_or_default();

6741

1

			assert_eq!(

6742

1,

6743

1

				collator_snapshot.delegations.len(),

6744

				"collator snapshot's delegator count was reduced unexpectedly"

6745

);

6746

1

			assert_eq!(

6747

				20, collator_snapshot.total,

6748

				"collator snapshot's total was reduced unexpectedly",

6749

);

6750

1

});

6751

1

6752

6753

#[test]

6754

1

fn test_delegator_scheduled_for_revoke_is_rewarded_when_request_cancelled() {

6755

1

	ExtBuilder::default()

6756

1

		.with_balances(vec![(1, 20), (2, 40), (3, 20), (4, 20)])

6757

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20)])

6758

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

6759

1

		.build()

6760

1

		.execute_with(|| {

6761

			// preset rewards for rounds 2, 3 and 4

6762

3

			(2..=4).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

6763

6764

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

6765

1

				RuntimeOrigin::signed(2),

6766

6767

));

6768

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

6769

1

				round: 1,

6770

1

				delegator: 2,

6771

1

				candidate: 1,

6772

1

				scheduled_exit: 3,

6773

1

});

6774

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

6775

1

			assert_eq!(

6776

				1, collator.delegation_count,

6777

				"collator's delegator count was reduced unexpectedly"

6778

);

6779

1

			assert_eq!(

6780

				30, collator.total_counted,

6781

				"collator's total was reduced unexpectedly"

6782

);

6783

6784

1

			roll_to_round_begin(2);

6785

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

6786

1

				RuntimeOrigin::signed(2),

6787

6788

));

6789

6790

1

			roll_to_round_begin(4);

6791

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

6792

1

			roll_blocks(3);

6793

1

			assert_events_eq!(Event::Rewarded {

6794

1

				account: 1,

6795

1

				rewards: 2,

6796

1

			},);

6797

1

			let collator_snapshot =

6798

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

6799

1

					.unwrap_or_default();

6800

1

			assert_eq!(

6801

1,

6802

1

				collator_snapshot.delegations.len(),

6803

				"collator snapshot's delegator count was reduced unexpectedly"

6804

);

6805

1

			assert_eq!(

6806

				30, collator_snapshot.total,

6807

				"collator snapshot's total was reduced unexpectedly",

6808

);

6809

6810

1

			roll_to_round_begin(5);

6811

1

			assert_events_emitted_match!(Event::NewRound { round: 5, .. });

6812

1

			roll_blocks(3);

6813

1

			assert_events_eq!(

6814

1

				Event::Rewarded {

6815

1

					account: 1,

6816

1

					rewards: 1,

6817

1

},

6818

1

				Event::Rewarded {

6819

1

					account: 2,

6820

1

					rewards: 1,

6821

1

},

6822

);

6823

1

});

6824

1

6825

6826

#[test]

6827

1

fn test_delegator_scheduled_for_bond_decrease_is_rewarded_for_previous_rounds_but_less_for_future()

6828

6829

1

	ExtBuilder::default()

6830

1

		.with_balances(vec![(1, 20), (2, 40), (3, 20), (4, 20)])

6831

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20)])

6832

1

		.with_delegations(vec![(2, 1, 20), (2, 3, 10)])

6833

1

		.build()

6834

1

		.execute_with(|| {

6835

			// preset rewards for rounds 1, 2 and 3

6836

3

			(1..=3).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

6837

6838

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

6839

1

				RuntimeOrigin::signed(2),

6840

1,

6841

10,

6842

));

6843

1

			assert_events_eq!(Event::DelegationDecreaseScheduled {

6844

1

				execute_round: 3,

6845

1

				delegator: 2,

6846

1

				candidate: 1,

6847

1

				amount_to_decrease: 10,

6848

1

});

6849

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

6850

1

			assert_eq!(

6851

				1, collator.delegation_count,

6852

				"collator's delegator count was reduced unexpectedly"

6853

);

6854

1

			assert_eq!(

6855

				40, collator.total_counted,

6856

				"collator's total was reduced unexpectedly"

6857

);

6858

6859

1

			roll_to_round_begin(3);

6860

1

			assert_events_emitted_match!(Event::NewRound { round: 3, .. });

6861

1

			roll_blocks(3);

6862

1

			assert_events_eq!(

6863

1

				Event::Rewarded {

6864

1

					account: 1,

6865

1

					rewards: 2,

6866

1

},

6867

1

				Event::Rewarded {

6868

1

					account: 2,

6869

1

					rewards: 1,

6870

1

},

6871

);

6872

6873

1

			roll_to_round_begin(4);

6874

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

6875

1

			roll_blocks(3);

6876

1

			assert_events_eq!(

6877

1

				Event::Rewarded {

6878

1

					account: 1,

6879

1

					rewards: 1,

6880

1

},

6881

1

				Event::Rewarded {

6882

1

					account: 2,

6883

1

					rewards: 1,

6884

1

},

6885

);

6886

1

			let collator_snapshot =

6887

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

6888

1

					.unwrap_or_default();

6889

1

			assert_eq!(

6890

1,

6891

1

				collator_snapshot.delegations.len(),

6892

				"collator snapshot's delegator count was reduced unexpectedly"

6893

);

6894

1

			assert_eq!(

6895

				30, collator_snapshot.total,

6896

				"collator snapshot's total was reduced unexpectedly",

6897

);

6898

1

});

6899

1

6900

6901

#[test]

6902

1

fn test_delegator_scheduled_for_bond_decrease_is_rewarded_when_request_cancelled() {

6903

1

	ExtBuilder::default()

6904

1

		.with_balances(vec![(1, 20), (2, 40), (3, 20), (4, 20)])

6905

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20)])

6906

1

		.with_delegations(vec![(2, 1, 20), (2, 3, 10)])

6907

1

		.build()

6908

1

		.execute_with(|| {

6909

			// preset rewards for rounds 2, 3 and 4

6910

3

			(2..=4).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

6911

6912

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

6913

1

				RuntimeOrigin::signed(2),

6914

1,

6915

10,

6916

));

6917

1

			assert_events_eq!(Event::DelegationDecreaseScheduled {

6918

1

				execute_round: 3,

6919

1

				delegator: 2,

6920

1

				candidate: 1,

6921

1

				amount_to_decrease: 10,

6922

1

});

6923

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

6924

1

			assert_eq!(

6925

				1, collator.delegation_count,

6926

				"collator's delegator count was reduced unexpectedly"

6927

);

6928

1

			assert_eq!(

6929

				40, collator.total_counted,

6930

				"collator's total was reduced unexpectedly"

6931

);

6932

6933

1

			roll_to_round_begin(2);

6934

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

6935

1

				RuntimeOrigin::signed(2),

6936

6937

));

6938

6939

1

			roll_to_round_begin(4);

6940

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

6941

1

			roll_blocks(3);

6942

1

			assert_events_eq!(

6943

1

				Event::Rewarded {

6944

1

					account: 1,

6945

1

					rewards: 1,

6946

1

},

6947

1

				Event::Rewarded {

6948

1

					account: 2,

6949

1

					rewards: 1,

6950

1

},

6951

);

6952

1

			let collator_snapshot =

6953

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

6954

1

					.unwrap_or_default();

6955

1

			assert_eq!(

6956

1,

6957

1

				collator_snapshot.delegations.len(),

6958

				"collator snapshot's delegator count was reduced unexpectedly"

6959

);

6960

1

			assert_eq!(

6961

				40, collator_snapshot.total,

6962

				"collator snapshot's total was reduced unexpectedly",

6963

);

6964

6965

1

			roll_to_round_begin(5);

6966

1

			assert_events_emitted_match!(Event::NewRound { round: 5, .. });

6967

1

			roll_blocks(3);

6968

1

			assert_events_eq!(

6969

1

				Event::Rewarded {

6970

1

					account: 1,

6971

1

					rewards: 1,

6972

1

},

6973

1

				Event::Rewarded {

6974

1

					account: 2,

6975

1

					rewards: 1,

6976

1

},

6977

);

6978

1

});

6979

1

6980

6981

#[test]

6982

1

fn test_delegator_scheduled_for_leave_is_rewarded_for_previous_rounds_but_not_for_future() {

6983

1

	ExtBuilder::default()

6984

1

		.with_balances(vec![(1, 20), (2, 40), (3, 20), (4, 20)])

6985

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20)])

6986

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

6987

1

		.build()

6988

1

		.execute_with(|| {

6989

			// preset rewards for rounds 1, 2 and 3

6990

3

			(1..=3).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

6991

6992

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

6993

1

				RuntimeOrigin::signed(2),

6994

1,

6995

));

6996

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

6997

1

				RuntimeOrigin::signed(2),

6998

3,

6999

));

7000

1

			assert_events_eq!(

7001

1

				Event::DelegationRevocationScheduled {

7002

1

					round: 1,

7003

1

					delegator: 2,

7004

1

					candidate: 1,

7005

1

					scheduled_exit: 3,

7006

1

},

7007

1

				Event::DelegationRevocationScheduled {

7008

1

					round: 1,

7009

1

					delegator: 2,

7010

1

					candidate: 3,

7011

1

					scheduled_exit: 3,

7012

1

},

7013

);

7014

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

7015

1

			assert_eq!(

7016

				1, collator.delegation_count,

7017

				"collator's delegator count was reduced unexpectedly"

7018

);

7019

1

			assert_eq!(

7020

				30, collator.total_counted,

7021

				"collator's total was reduced unexpectedly"

7022

);

7023

7024

1

			roll_to_round_begin(3);

7025

1

			assert_events_emitted_match!(Event::NewRound { round: 3, .. });

7026

1

			roll_blocks(3);

7027

1

			assert_events_eq!(

7028

1

				Event::Rewarded {

7029

1

					account: 1,

7030

1

					rewards: 2,

7031

1

},

7032

1

				Event::Rewarded {

7033

1

					account: 2,

7034

1

					rewards: 1,

7035

1

},

7036

);

7037

7038

1

			roll_to_round_begin(4);

7039

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

7040

1

			roll_blocks(3);

7041

1

			assert_events_eq!(Event::Rewarded {

7042

1

				account: 1,

7043

1

				rewards: 2,

7044

1

			},);

7045

1

			let collator_snapshot =

7046

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

7047

1

					.unwrap_or_default();

7048

1

			assert_eq!(

7049

1,

7050

1

				collator_snapshot.delegations.len(),

7051

				"collator snapshot's delegator count was reduced unexpectedly"

7052

);

7053

1

			assert_eq!(

7054

				20, collator_snapshot.total,

7055

				"collator snapshot's total was reduced unexpectedly",

7056

);

7057

1

});

7058

1

7059

7060

#[test]

7061

1

fn test_delegator_scheduled_for_leave_is_rewarded_when_request_cancelled() {

7062

1

	ExtBuilder::default()

7063

1

		.with_balances(vec![(1, 20), (2, 40), (3, 20), (4, 20)])

7064

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20)])

7065

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

7066

1

		.build()

7067

1

		.execute_with(|| {

7068

			// preset rewards for rounds 2, 3 and 4

7069

3

			(2..=4).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

7070

7071

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7072

1

				RuntimeOrigin::signed(2),

7073

1,

7074

));

7075

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7076

1

				RuntimeOrigin::signed(2),

7077

3,

7078

));

7079

1

			assert_events_eq!(

7080

1

				Event::DelegationRevocationScheduled {

7081

1

					round: 1,

7082

1

					delegator: 2,

7083

1

					candidate: 1,

7084

1

					scheduled_exit: 3,

7085

1

},

7086

1

				Event::DelegationRevocationScheduled {

7087

1

					round: 1,

7088

1

					delegator: 2,

7089

1

					candidate: 3,

7090

1

					scheduled_exit: 3,

7091

1

},

7092

);

7093

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

7094

1

			assert_eq!(

7095

				1, collator.delegation_count,

7096

				"collator's delegator count was reduced unexpectedly"

7097

);

7098

1

			assert_eq!(

7099

				30, collator.total_counted,

7100

				"collator's total was reduced unexpectedly"

7101

);

7102

7103

1

			roll_to_round_begin(2);

7104

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

7105

1

				RuntimeOrigin::signed(2),

7106

1,

7107

));

7108

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

7109

1

				RuntimeOrigin::signed(2),

7110

3,

7111

));

7112

7113

1

			roll_to_round_begin(4);

7114

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

7115

1

			roll_blocks(3);

7116

1

			assert_events_eq!(Event::Rewarded {

7117

1

				account: 1,

7118

1

				rewards: 2,

7119

1

			},);

7120

1

			let collator_snapshot =

7121

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

7122

1

					.unwrap_or_default();

7123

1

			assert_eq!(

7124

1,

7125

1

				collator_snapshot.delegations.len(),

7126

				"collator snapshot's delegator count was reduced unexpectedly"

7127

);

7128

1

			assert_eq!(

7129

				30, collator_snapshot.total,

7130

				"collator snapshot's total was reduced unexpectedly",

7131

);

7132

7133

1

			roll_to_round_begin(5);

7134

1

			assert_events_emitted_match!(Event::NewRound { round: 5, .. });

7135

1

			roll_blocks(3);

7136

1

			assert_events_eq!(

7137

1

				Event::Rewarded {

7138

1

					account: 1,

7139

1

					rewards: 1,

7140

1

},

7141

1

				Event::Rewarded {

7142

1

					account: 2,

7143

1

					rewards: 1,

7144

1

},

7145

);

7146

1

});

7147

1

7148

7149

#[test]

7150

1

fn test_delegation_request_exists_returns_false_when_nothing_exists() {

7151

1

	ExtBuilder::default()

7152

1

		.with_balances(vec![(1, 30), (2, 25)])

7153

1

		.with_candidates(vec![(1, 30)])

7154

1

		.with_delegations(vec![(2, 1, 10)])

7155

1

		.build()

7156

1

		.execute_with(|| {

7157

1

			assert!(!ParachainStaking::delegation_request_exists(&1, &2));

7158

1

});

7159

1

7160

7161

#[test]

7162

1

fn test_delegation_request_exists_returns_true_when_decrease_exists() {

7163

1

	ExtBuilder::default()

7164

1

		.with_balances(vec![(1, 30), (2, 25)])

7165

1

		.with_candidates(vec![(1, 30)])

7166

1

		.with_delegations(vec![(2, 1, 10)])

7167

1

		.build()

7168

1

		.execute_with(|| {

7169

1

			<DelegationScheduledRequests<Test>>::insert(

7170

1,

7171

2,

7172

1

				BoundedVec::try_from(vec![ScheduledRequest {

7173

1

					when_executable: 3,

7174

1

					action: DelegationAction::Decrease(5),

7175

1

}])

7176

1

				.expect("must succeed"),

7177

);

7178

1

			assert!(ParachainStaking::delegation_request_exists(&1, &2));

7179

1

});

7180

1

7181

7182

#[test]

7183

1

fn test_delegation_request_exists_returns_true_when_revoke_exists() {

7184

1

	ExtBuilder::default()

7185

1

		.with_balances(vec![(1, 30), (2, 25)])

7186

1

		.with_candidates(vec![(1, 30)])

7187

1

		.with_delegations(vec![(2, 1, 10)])

7188

1

		.build()

7189

1

		.execute_with(|| {

7190

1

			<DelegationScheduledRequests<Test>>::insert(

7191

1,

7192

2,

7193

1

				BoundedVec::try_from(vec![ScheduledRequest {

7194

1

					when_executable: 3,

7195

1

					action: DelegationAction::Revoke(5),

7196

1

}])

7197

1

				.expect("must succeed"),

7198

);

7199

1

			assert!(ParachainStaking::delegation_request_exists(&1, &2));

7200

1

});

7201

1

7202

7203

#[test]

7204

1

fn test_delegation_request_revoke_exists_returns_false_when_nothing_exists() {

7205

1

	ExtBuilder::default()

7206

1

		.with_balances(vec![(1, 30), (2, 25)])

7207

1

		.with_candidates(vec![(1, 30)])

7208

1

		.with_delegations(vec![(2, 1, 10)])

7209

1

		.build()

7210

1

		.execute_with(|| {

7211

1

			assert!(!ParachainStaking::delegation_request_revoke_exists(&1, &2));

7212

1

});

7213

1

7214

7215

#[test]

7216

1

fn test_delegation_request_revoke_exists_returns_false_when_decrease_exists() {

7217

1

	ExtBuilder::default()

7218

1

		.with_balances(vec![(1, 30), (2, 25)])

7219

1

		.with_candidates(vec![(1, 30)])

7220

1

		.with_delegations(vec![(2, 1, 10)])

7221

1

		.build()

7222

1

		.execute_with(|| {

7223

1

			<DelegationScheduledRequests<Test>>::insert(

7224

1,

7225

2,

7226

1

				BoundedVec::try_from(vec![ScheduledRequest {

7227

1

					when_executable: 3,

7228

1

					action: DelegationAction::Decrease(5),

7229

1

}])

7230

1

				.expect("must succeed"),

7231

);

7232

1

			assert!(!ParachainStaking::delegation_request_revoke_exists(&1, &2));

7233

1

});

7234

1

7235

7236

#[test]

7237

1

fn test_delegation_request_revoke_exists_returns_true_when_revoke_exists() {

7238

1

	ExtBuilder::default()

7239

1

		.with_balances(vec![(1, 30), (2, 25)])

7240

1

		.with_candidates(vec![(1, 30)])

7241

1

		.with_delegations(vec![(2, 1, 10)])

7242

1

		.build()

7243

1

		.execute_with(|| {

7244

1

			<DelegationScheduledRequests<Test>>::insert(

7245

1,

7246

2,

7247

1

				BoundedVec::try_from(vec![ScheduledRequest {

7248

1

					when_executable: 3,

7249

1

					action: DelegationAction::Revoke(5),

7250

1

}])

7251

1

				.expect("must succeed"),

7252

);

7253

1

			assert!(ParachainStaking::delegation_request_revoke_exists(&1, &2));

7254

1

});

7255

1

7256

7257

#[test]

7258

1

fn locking_zero_amount_removes_lock() {

7259

	// this test demonstrates the behavior of fungible's freeze mechanism

7260

7261

1

	ExtBuilder::default()

7262

1

		.with_balances(vec![(1, 100)])

7263

1

		.build()

7264

1

		.execute_with(|| {

7265

1

			let reason = &crate::pallet::FreezeReason::StakingDelegator.into();

7266

1

			assert_eq!(query_freeze_amount(1, reason), 0);

7267

7268

			// Freeze 1 unit

7269

1

			assert_ok!(Balances::set_freeze(reason, &1, 1));

7270

1

			assert_eq!(query_freeze_amount(1, reason), 1);

7271

7272

			// Thaw the freeze

7273

1

			assert_ok!(Balances::thaw(reason, &1));

7274

1

			assert_eq!(query_freeze_amount(1, reason), 0);

7275

1

});

7276

1

7277

7278

#[test]

7279

1

fn revoke_last_removes_freeze() {

7280

	use crate::mock::query_freeze_amount;

7281

7282

1

	ExtBuilder::default()

7283

1

		.with_balances(vec![(1, 100), (2, 100), (3, 100)])

7284

1

		.with_candidates(vec![(1, 25), (2, 25)])

7285

1

		.with_delegations(vec![(3, 1, 30), (3, 2, 25)])

7286

1

		.build()

7287

1

		.execute_with(|| {

7288

1

			let reason = &crate::pallet::FreezeReason::StakingDelegator.into();

7289

1

			assert_eq!(query_freeze_amount(3, reason), 55);

7290

7291

			// schedule and remove one...

7292

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7293

1

				RuntimeOrigin::signed(3),

7294

7295

));

7296

1

			roll_to_round_begin(3);

7297

1

			assert_ok!(ParachainStaking::execute_delegation_request(

7298

1

				RuntimeOrigin::signed(3),

7299

3,

7300

7301

));

7302

1

			assert_eq!(query_freeze_amount(3, reason), 25);

7303

7304

			// schedule and remove the other...

7305

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7306

1

				RuntimeOrigin::signed(3),

7307

7308

));

7309

1

			roll_to_round_begin(5);

7310

1

			assert_ok!(ParachainStaking::execute_delegation_request(

7311

1

				RuntimeOrigin::signed(3),

7312

3,

7313

7314

));

7315

1

			assert_eq!(query_freeze_amount(3, reason), 0);

7316

1

});

7317

1

7318

7319

#[test]

7320

1

fn test_set_auto_compound_fails_if_invalid_delegation_hint() {

7321

1

	ExtBuilder::default()

7322

1

		.with_balances(vec![(1, 30), (2, 25)])

7323

1

		.with_candidates(vec![(1, 30)])

7324

1

		.with_delegations(vec![(2, 1, 10)])

7325

1

		.build()

7326

1

		.execute_with(|| {

7327

1

			let candidate_auto_compounding_delegation_count_hint = 0;

7328

1

			let delegation_hint = 0; // is however, 1

7329

7330

1

			assert_noop!(

7331

1

				ParachainStaking::set_auto_compound(

7332

1

					RuntimeOrigin::signed(2),

7333

1,

7334

1

					Percent::from_percent(50),

7335

1

					candidate_auto_compounding_delegation_count_hint,

7336

1

					delegation_hint,

7337

),

7338

1

				<Error<Test>>::TooLowDelegationCountToAutoCompound,

7339

);

7340

1

});

7341

1

7342

7343

#[test]

7344

1

fn test_set_auto_compound_fails_if_invalid_candidate_auto_compounding_hint() {

7345

1

	ExtBuilder::default()

7346

1

		.with_balances(vec![(1, 30), (2, 25)])

7347

1

		.with_candidates(vec![(1, 30)])

7348

1

		.with_delegations(vec![(2, 1, 10)])

7349

1

		.build()

7350

1

		.execute_with(|| {

7351

1

			<AutoCompoundDelegations<Test>>::new(

7352

1

				vec![AutoCompoundConfig {

7353

1

					delegator: 2,

7354

1

					value: Percent::from_percent(10),

7355

1

}]

7356

1

				.try_into()

7357

1

				.expect("must succeed"),

7358

7359

1

			.set_storage(&1);

7360

1

			let candidate_auto_compounding_delegation_count_hint = 0; // is however, 1

7361

1

			let delegation_hint = 1;

7362

7363

1

			assert_noop!(

7364

1

				ParachainStaking::set_auto_compound(

7365

1

					RuntimeOrigin::signed(2),

7366

1,

7367

1

					Percent::from_percent(50),

7368

1

					candidate_auto_compounding_delegation_count_hint,

7369

1

					delegation_hint,

7370

),

7371

1

				<Error<Test>>::TooLowCandidateAutoCompoundingDelegationCountToAutoCompound,

7372

);

7373

1

});

7374

1

7375

7376

#[test]

7377

1

fn test_set_auto_compound_inserts_if_not_exists() {

7378

1

	ExtBuilder::default()

7379

1

		.with_balances(vec![(1, 30), (2, 25)])

7380

1

		.with_candidates(vec![(1, 30)])

7381

1

		.with_delegations(vec![(2, 1, 10)])

7382

1

		.build()

7383

1

		.execute_with(|| {

7384

1

			assert_ok!(ParachainStaking::set_auto_compound(

7385

1

				RuntimeOrigin::signed(2),

7386

1,

7387

1

				Percent::from_percent(50),

7388

0,

7389

1,

7390

));

7391

1

			assert_events_emitted!(Event::AutoCompoundSet {

7392

1

				candidate: 1,

7393

1

				delegator: 2,

7394

1

				value: Percent::from_percent(50),

7395

1

});

7396

1

			assert_eq!(

7397

1

				vec![AutoCompoundConfig {

7398

1

					delegator: 2,

7399

1

					value: Percent::from_percent(50),

7400

1

}],

7401

1

				ParachainStaking::auto_compounding_delegations(&1).into_inner(),

7402

);

7403

1

});

7404

1

7405

7406

#[test]

7407

1

fn test_set_auto_compound_updates_if_existing() {

7408

1

	ExtBuilder::default()

7409

1

		.with_balances(vec![(1, 30), (2, 25)])

7410

1

		.with_candidates(vec![(1, 30)])

7411

1

		.with_delegations(vec![(2, 1, 10)])

7412

1

		.build()

7413

1

		.execute_with(|| {

7414

1

			<AutoCompoundDelegations<Test>>::new(

7415

1

				vec![AutoCompoundConfig {

7416

1

					delegator: 2,

7417

1

					value: Percent::from_percent(10),

7418

1

}]

7419

1

				.try_into()

7420

1

				.expect("must succeed"),

7421

7422

1

			.set_storage(&1);

7423

7424

1

			assert_ok!(ParachainStaking::set_auto_compound(

7425

1

				RuntimeOrigin::signed(2),

7426

1,

7427

1

				Percent::from_percent(50),

7428

1,

7429

1,

7430

));

7431

1

			assert_events_emitted!(Event::AutoCompoundSet {

7432

1

				candidate: 1,

7433

1

				delegator: 2,

7434

1

				value: Percent::from_percent(50),

7435

1

});

7436

1

			assert_eq!(

7437

1

				vec![AutoCompoundConfig {

7438

1

					delegator: 2,

7439

1

					value: Percent::from_percent(50),

7440

1

}],

7441

1

				ParachainStaking::auto_compounding_delegations(&1).into_inner(),

7442

);

7443

1

});

7444

1

7445

7446

#[test]

7447

1

fn test_set_auto_compound_removes_if_auto_compound_zero_percent() {

7448

1

	ExtBuilder::default()

7449

1

		.with_balances(vec![(1, 30), (2, 25)])

7450

1

		.with_candidates(vec![(1, 30)])

7451

1

		.with_delegations(vec![(2, 1, 10)])

7452

1

		.build()

7453

1

		.execute_with(|| {

7454

1

			<AutoCompoundDelegations<Test>>::new(

7455

1

				vec![AutoCompoundConfig {

7456

1

					delegator: 2,

7457

1

					value: Percent::from_percent(10),

7458

1

}]

7459

1

				.try_into()

7460

1

				.expect("must succeed"),

7461

7462

1

			.set_storage(&1);

7463

7464

1

			assert_ok!(ParachainStaking::set_auto_compound(

7465

1

				RuntimeOrigin::signed(2),

7466

1,

7467

1

				Percent::zero(),

7468

1,

7469

1,

7470

));

7471

1

			assert_events_emitted!(Event::AutoCompoundSet {

7472

1

				candidate: 1,

7473

1

				delegator: 2,

7474

1

				value: Percent::zero(),

7475

1

});

7476

1

			assert_eq!(0, ParachainStaking::auto_compounding_delegations(&1).len(),);

7477

1

});

7478

1

7479

7480

#[test]

7481

1

fn test_execute_revoke_delegation_removes_auto_compounding_from_state_for_delegation_revoke() {

7482

1

	ExtBuilder::default()

7483

1

		.with_balances(vec![(1, 30), (2, 30), (3, 20)])

7484

1

		.with_candidates(vec![(1, 30), (3, 20)])

7485

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

7486

1

		.build()

7487

1

		.execute_with(|| {

7488

1

			assert_ok!(ParachainStaking::set_auto_compound(

7489

1

				RuntimeOrigin::signed(2),

7490

1,

7491

1

				Percent::from_percent(50),

7492

0,

7493

2,

7494

));

7495

1

			assert_ok!(ParachainStaking::set_auto_compound(

7496

1

				RuntimeOrigin::signed(2),

7497

3,

7498

1

				Percent::from_percent(50),

7499

0,

7500

2,

7501

));

7502

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7503

1

				RuntimeOrigin::signed(2),

7504

7505

));

7506

1

			roll_to(10);

7507

1

			assert_ok!(ParachainStaking::execute_delegation_request(

7508

1

				RuntimeOrigin::signed(2),

7509

2,

7510

7511

));

7512

1

			assert!(

7513

1

				!ParachainStaking::auto_compounding_delegations(&1)

7514

1

					.iter()

7515

1

					.any(|x| x.delegator == 2),

7516

				"delegation auto-compound config was not removed"

7517

);

7518

1

			assert!(

7519

1

				ParachainStaking::auto_compounding_delegations(&3)

7520

1

					.iter()

7521

1

					.any(|x| x.delegator == 2),

7522

				"delegation auto-compound config was erroneously removed"

7523

);

7524

1

});

7525

1

7526

7527

#[test]

7528

1

fn test_execute_leave_delegators_removes_auto_compounding_state() {

7529

1

	ExtBuilder::default()

7530

1

		.with_balances(vec![(1, 30), (2, 20), (3, 20)])

7531

1

		.with_candidates(vec![(1, 30), (3, 20)])

7532

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

7533

1

		.build()

7534

1

		.execute_with(|| {

7535

1

			assert_ok!(ParachainStaking::set_auto_compound(

7536

1

				RuntimeOrigin::signed(2),

7537

1,

7538

1

				Percent::from_percent(50),

7539

0,

7540

2,

7541

));

7542

1

			assert_ok!(ParachainStaking::set_auto_compound(

7543

1

				RuntimeOrigin::signed(2),

7544

3,

7545

1

				Percent::from_percent(50),

7546

0,

7547

2,

7548

));

7549

7550

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7551

1

				RuntimeOrigin::signed(2),

7552

1,

7553

));

7554

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7555

1

				RuntimeOrigin::signed(2),

7556

3,

7557

));

7558

1

			roll_to(10);

7559

1

			assert_ok!(ParachainStaking::execute_delegation_request(

7560

1

				RuntimeOrigin::signed(2),

7561

2,

7562

1,

7563

));

7564

1

			assert_ok!(ParachainStaking::execute_delegation_request(

7565

1

				RuntimeOrigin::signed(2),

7566

2,

7567

3,

7568

));

7569

7570

1

			assert!(

7571

1

				!ParachainStaking::auto_compounding_delegations(&1)

7572

1

					.iter()

7573

1

					.any(|x| x.delegator == 2),

7574

				"delegation auto-compound config was not removed"

7575

);

7576

1

			assert!(

7577

1

				!ParachainStaking::auto_compounding_delegations(&3)

7578

1

					.iter()

7579

1

					.any(|x| x.delegator == 2),

7580

				"delegation auto-compound config was not removed"

7581

);

7582

1

});

7583

1

7584

7585

#[test]

7586

1

fn test_execute_leave_candidates_removes_auto_compounding_state() {

7587

1

	ExtBuilder::default()

7588

1

		.with_balances(vec![(1, 30), (2, 20), (3, 20)])

7589

1

		.with_candidates(vec![(1, 30), (3, 20)])

7590

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

7591

1

		.build()

7592

1

		.execute_with(|| {

7593

1

			assert_ok!(ParachainStaking::set_auto_compound(

7594

1

				RuntimeOrigin::signed(2),

7595

1,

7596

1

				Percent::from_percent(50),

7597

0,

7598

2,

7599

));

7600

1

			assert_ok!(ParachainStaking::set_auto_compound(

7601

1

				RuntimeOrigin::signed(2),

7602

3,

7603

1

				Percent::from_percent(50),

7604

0,

7605

2,

7606

));

7607

7608

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

7609

1

				RuntimeOrigin::signed(1),

7610

7611

));

7612

1

			roll_to(10);

7613

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

7614

1

				RuntimeOrigin::signed(1),

7615

1,

7616

1,

7617

));

7618

7619

1

			assert!(

7620

1

				!ParachainStaking::auto_compounding_delegations(&1)

7621

1

					.iter()

7622

1

					.any(|x| x.delegator == 2),

7623

				"delegation auto-compound config was not removed"

7624

);

7625

1

			assert!(

7626

1

				ParachainStaking::auto_compounding_delegations(&3)

7627

1

					.iter()

7628

1

					.any(|x| x.delegator == 2),

7629

				"delegation auto-compound config was erroneously removed"

7630

);

7631

1

});

7632

1

7633

7634

#[test]

7635

1

fn test_delegation_kicked_from_bottom_delegation_removes_auto_compounding_state() {

7636

1

	ExtBuilder::default()

7637

1

		.with_balances(vec![

7638

1

			(1, 30),

7639

1

			(2, 29),

7640

1

			(3, 20),

7641

1

			(4, 20),

7642

1

			(5, 20),

7643

1

			(6, 20),

7644

1

			(7, 20),

7645

1

			(8, 20),

7646

1

			(9, 20),

7647

1

			(10, 20),

7648

1

			(11, 30),

7649

1

])

7650

1

		.with_candidates(vec![(1, 30), (11, 30)])

7651

1

		.with_delegations(vec![

7652

1

			(2, 11, 10), // extra delegation to avoid leaving the delegator set

7653

1

			(2, 1, 19),

7654

1

			(3, 1, 20),

7655

1

			(4, 1, 20),

7656

1

			(5, 1, 20),

7657

1

			(6, 1, 20),

7658

1

			(7, 1, 20),

7659

1

			(8, 1, 20),

7660

1

			(9, 1, 20),

7661

1

])

7662

1

		.build()

7663

1

		.execute_with(|| {

7664

1

			assert_ok!(ParachainStaking::set_auto_compound(

7665

1

				RuntimeOrigin::signed(2),

7666

1,

7667

1

				Percent::from_percent(50),

7668

0,

7669

2,

7670

));

7671

7672

			// kicks lowest delegation (2, 19)

7673

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

7674

1

				RuntimeOrigin::signed(10),

7675

1,

7676

20,

7677

1

				Percent::zero(),

7678

8,

7679

0,

7680

0,

7681

));

7682

7683

1

			assert!(

7684

1

				!ParachainStaking::auto_compounding_delegations(&1)

7685

1

					.iter()

7686

1

					.any(|x| x.delegator == 2),

7687

				"delegation auto-compound config was not removed"

7688

);

7689

1

});

7690

1

7691

7692

#[test]

7693

1

fn test_rewards_do_not_auto_compound_on_payment_if_delegation_scheduled_revoke_exists() {

7694

1

	ExtBuilder::default()

7695

1

		.with_balances(vec![(1, 100), (2, 200), (3, 200)])

7696

1

		.with_candidates(vec![(1, 100)])

7697

1

		.with_delegations(vec![(2, 1, 200), (3, 1, 200)])

7698

1

		.build()

7699

1

		.execute_with(|| {

7700

4

			(2..=5).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

7701

1

			assert_ok!(ParachainStaking::set_auto_compound(

7702

1

				RuntimeOrigin::signed(2),

7703

1,

7704

1

				Percent::from_percent(50),

7705

0,

7706

1,

7707

));

7708

1

			assert_ok!(ParachainStaking::set_auto_compound(

7709

1

				RuntimeOrigin::signed(3),

7710

1,

7711

1

				Percent::from_percent(50),

7712

1,

7713

1,

7714

));

7715

1

			roll_to_round_begin(3);

7716

7717

			// schedule revoke for delegator 2; no rewards should be compounded

7718

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7719

1

				RuntimeOrigin::signed(2),

7720

7721

));

7722

1

			roll_to_round_begin(4);

7723

7724

1

			assert_events_eq!(

7725

1

				Event::CollatorChosen {

7726

1

					round: 4,

7727

1

					collator_account: 1,

7728

1

					total_exposed_amount: 500,

7729

1

},

7730

1

				Event::NewRound {

7731

1

					starting_block: 15,

7732

1

					round: 4,

7733

1

					selected_collators_number: 1,

7734

1

					total_balance: 500,

7735

1

},

7736

);

7737

7738

1

			roll_blocks(1);

7739

1

			assert_events_eq!(

7740

1

				Event::Rewarded {

7741

1

					account: 1,

7742

1

					rewards: 4,

7743

1

},

7744

				// no compound since revoke request exists

7745

1

				Event::Rewarded {

7746

1

					account: 2,

7747

1

					rewards: 4,

7748

1

},

7749

				// 50%

7750

1

				Event::Rewarded {

7751

1

					account: 3,

7752

1

					rewards: 4,

7753

1

},

7754

1

				Event::Compounded {

7755

1

					candidate: 1,

7756

1

					delegator: 3,

7757

1

					amount: 2,

7758

1

},

7759

);

7760

1

});

7761

1

7762

7763

#[test]

7764

1

fn test_rewards_auto_compound_on_payment_as_per_auto_compound_config() {

7765

1

	ExtBuilder::default()

7766

1

		.with_balances(vec![(1, 100), (2, 200), (3, 200), (4, 200), (5, 200)])

7767

1

		.with_candidates(vec![(1, 100)])

7768

1

		.with_delegations(vec![(2, 1, 200), (3, 1, 200), (4, 1, 200), (5, 1, 200)])

7769

1

		.build()

7770

1

		.execute_with(|| {

7771

5

			(2..=6).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

7772

1

			assert_ok!(ParachainStaking::set_auto_compound(

7773

1

				RuntimeOrigin::signed(2),

7774

1,

7775

1

				Percent::from_percent(0),

7776

0,

7777

1,

7778

));

7779

1

			assert_ok!(ParachainStaking::set_auto_compound(

7780

1

				RuntimeOrigin::signed(3),

7781

1,

7782

1

				Percent::from_percent(50),

7783

1,

7784

1,

7785

));

7786

1

			assert_ok!(ParachainStaking::set_auto_compound(

7787

1

				RuntimeOrigin::signed(4),

7788

1,

7789

1

				Percent::from_percent(100),

7790

2,

7791

1,

7792

));

7793

1

			roll_to_round_begin(4);

7794

7795

1

			assert_events_eq!(

7796

1

				Event::CollatorChosen {

7797

1

					round: 4,

7798

1

					collator_account: 1,

7799

1

					total_exposed_amount: 900,

7800

1

},

7801

1

				Event::NewRound {

7802

1

					starting_block: 15,

7803

1

					round: 4,

7804

1

					selected_collators_number: 1,

7805

1

					total_balance: 900,

7806

1

},

7807

);

7808

7809

1

			roll_blocks(1);

7810

1

			assert_events_eq!(

7811

1

				Event::Rewarded {

7812

1

					account: 1,

7813

1

					rewards: 6,

7814

1

},

7815

				// 0%

7816

1

				Event::Rewarded {

7817

1

					account: 2,

7818

1

					rewards: 4,

7819

1

},

7820

				// 50%

7821

1

				Event::Rewarded {

7822

1

					account: 3,

7823

1

					rewards: 4,

7824

1

},

7825

1

				Event::Compounded {

7826

1

					candidate: 1,

7827

1

					delegator: 3,

7828

1

					amount: 2,

7829

1

},

7830

				// 100%

7831

1

				Event::Rewarded {

7832

1

					account: 4,

7833

1

					rewards: 4,

7834

1

},

7835

1

				Event::Compounded {

7836

1

					candidate: 1,

7837

1

					delegator: 4,

7838

1

					amount: 4,

7839

1

},

7840

				// no-config

7841

1

				Event::Rewarded {

7842

1

					account: 5,

7843

1

					rewards: 4,

7844

1

},

7845

);

7846

1

});

7847

1

7848

7849

#[test]

7850

1

fn test_delegate_with_auto_compound_fails_if_invalid_delegation_hint() {

7851

1

	ExtBuilder::default()

7852

1

		.with_balances(vec![(1, 30), (2, 25), (3, 30)])

7853

1

		.with_candidates(vec![(1, 30), (3, 30)])

7854

1

		.with_delegations(vec![(2, 3, 10)])

7855

1

		.build()

7856

1

		.execute_with(|| {

7857

1

			let candidate_delegation_count_hint = 0;

7858

1

			let candidate_auto_compounding_delegation_count_hint = 0;

7859

1

			let delegation_hint = 0; // is however, 1

7860

7861

1

			assert_noop!(

7862

1

				ParachainStaking::delegate_with_auto_compound(

7863

1

					RuntimeOrigin::signed(2),

7864

1,

7865

10,

7866

1

					Percent::from_percent(50),

7867

1

					candidate_delegation_count_hint,

7868

1

					candidate_auto_compounding_delegation_count_hint,

7869

1

					delegation_hint,

7870

),

7871

1

				<Error<Test>>::TooLowDelegationCountToDelegate,

7872

);

7873

1

});

7874

1

7875

7876

#[test]

7877

1

fn test_delegate_with_auto_compound_fails_if_invalid_candidate_delegation_count_hint() {

7878

1

	ExtBuilder::default()

7879

1

		.with_balances(vec![(1, 30), (2, 25), (3, 30)])

7880

1

		.with_candidates(vec![(1, 30)])

7881

1

		.with_delegations(vec![(3, 1, 10)])

7882

1

		.build()

7883

1

		.execute_with(|| {

7884

1

			let candidate_delegation_count_hint = 0; // is however, 1

7885

1

			let candidate_auto_compounding_delegation_count_hint = 0;

7886

1

			let delegation_hint = 0;

7887

7888

1

			assert_noop!(

7889

1

				ParachainStaking::delegate_with_auto_compound(

7890

1

					RuntimeOrigin::signed(2),

7891

1,

7892

10,

7893

1

					Percent::from_percent(50),

7894

1

					candidate_delegation_count_hint,

7895

1

					candidate_auto_compounding_delegation_count_hint,

7896

1

					delegation_hint,

7897

),

7898

1

				<Error<Test>>::TooLowCandidateDelegationCountToDelegate,

7899

);

7900

1

});

7901

1

7902

7903

#[test]

7904

1

fn test_delegate_with_auto_compound_fails_if_invalid_candidate_auto_compounding_delegations_hint() {

7905

1

	ExtBuilder::default()

7906

1

		.with_balances(vec![(1, 30), (2, 25), (3, 30)])

7907

1

		.with_candidates(vec![(1, 30)])

7908

1

		.with_auto_compounding_delegations(vec![(3, 1, 10, Percent::from_percent(10))])

7909

1

		.build()

7910

1

		.execute_with(|| {

7911

1

			let candidate_delegation_count_hint = 1;

7912

1

			let candidate_auto_compounding_delegation_count_hint = 0; // is however, 1

7913

1

			let delegation_hint = 0;

7914

7915

1

			assert_noop!(

7916

1

				ParachainStaking::delegate_with_auto_compound(

7917

1

					RuntimeOrigin::signed(2),

7918

1,

7919

10,

7920

1

					Percent::from_percent(50),

7921

1

					candidate_delegation_count_hint,

7922

1

					candidate_auto_compounding_delegation_count_hint,

7923

1

					delegation_hint,

7924

),

7925

1

				<Error<Test>>::TooLowCandidateAutoCompoundingDelegationCountToDelegate,

7926

);

7927

1

});

7928

1

7929

7930

#[test]

7931

1

fn test_delegate_with_auto_compound_sets_auto_compound_config() {

7932

1

	ExtBuilder::default()

7933

1

		.with_balances(vec![(1, 30), (2, 25)])

7934

1

		.with_candidates(vec![(1, 30)])

7935

1

		.build()

7936

1

		.execute_with(|| {

7937

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

7938

1

				RuntimeOrigin::signed(2),

7939

1,

7940

10,

7941

1

				Percent::from_percent(50),

7942

0,

7943

0,

7944

0,

7945

));

7946

1

			assert_events_emitted!(Event::Delegation {

7947

1

				delegator: 2,

7948

1

				locked_amount: 10,

7949

1

				candidate: 1,

7950

1

				delegator_position: DelegatorAdded::AddedToTop { new_total: 40 },

7951

1

				auto_compound: Percent::from_percent(50),

7952

1

});

7953

1

			assert_eq!(

7954

1

				vec![AutoCompoundConfig {

7955

1

					delegator: 2,

7956

1

					value: Percent::from_percent(50),

7957

1

}],

7958

1

				ParachainStaking::auto_compounding_delegations(&1).into_inner(),

7959

);

7960

1

});

7961

1

7962

7963

#[test]

7964

1

fn test_delegate_with_auto_compound_skips_storage_but_emits_event_for_zero_auto_compound() {

7965

1

	ExtBuilder::default()

7966

1

		.with_balances(vec![(1, 30), (2, 10)])

7967

1

		.with_candidates(vec![(1, 30)])

7968

1

		.build()

7969

1

		.execute_with(|| {

7970

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

7971

1

				RuntimeOrigin::signed(2),

7972

1,

7973

10,

7974

1

				Percent::zero(),

7975

0,

7976

0,

7977

0,

7978

));

7979

1

			assert_eq!(0, ParachainStaking::auto_compounding_delegations(&1).len(),);

7980

1

			assert_events_eq!(Event::Delegation {

7981

1

				delegator: 2,

7982

1

				locked_amount: 10,

7983

1

				candidate: 1,

7984

1

				delegator_position: DelegatorAdded::AddedToTop { new_total: 40 },

7985

1

				auto_compound: Percent::zero(),

7986

1

});

7987

1

});

7988

1

7989

7990

#[test]

7991

1

fn test_delegate_with_auto_compound_reserves_balance() {

7992

1

	ExtBuilder::default()

7993

1

		.with_balances(vec![(1, 30), (2, 10)])

7994

1

		.with_candidates(vec![(1, 30)])

7995

1

		.build()

7996

1

		.execute_with(|| {

7997

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 10);

7998

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

7999

1

				RuntimeOrigin::signed(2),

8000

1,

8001

10,

8002

1

				Percent::from_percent(50),

8003

0,

8004

0,

8005

0,

8006

));

8007

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 0);

8008

1

});

8009

1

8010

8011

#[test]

8012

1

fn test_delegate_with_auto_compound_updates_delegator_state() {

8013

1

	ExtBuilder::default()

8014

1

		.with_balances(vec![(1, 30), (2, 10)])

8015

1

		.with_candidates(vec![(1, 30)])

8016

1

		.build()

8017

1

		.execute_with(|| {

8018

1

			assert!(ParachainStaking::delegator_state(2).is_none());

8019

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8020

1

				RuntimeOrigin::signed(2),

8021

1,

8022

10,

8023

1

				Percent::from_percent(50),

8024

0,

8025

0,

8026

8027

));

8028

1

			let delegator_state =

8029

1

				ParachainStaking::delegator_state(2).expect("just delegated => exists");

8030

1

			assert_eq!(delegator_state.total(), 10);

8031

1

			assert_eq!(delegator_state.delegations.0[0].owner, 1);

8032

1

			assert_eq!(delegator_state.delegations.0[0].amount, 10);

8033

1

});

8034

1

8035

8036

#[test]

8037

1

fn test_delegate_with_auto_compound_updates_collator_state() {

8038

1

	ExtBuilder::default()

8039

1

		.with_balances(vec![(1, 30), (2, 10)])

8040

1

		.with_candidates(vec![(1, 30)])

8041

1

		.build()

8042

1

		.execute_with(|| {

8043

1

			let candidate_state =

8044

1

				ParachainStaking::candidate_info(1).expect("registered in genesis");

8045

1

			assert_eq!(candidate_state.total_counted, 30);

8046

1

			let top_delegations =

8047

1

				ParachainStaking::top_delegations(1).expect("registered in genesis");

8048

1

			assert!(top_delegations.delegations.is_empty());

8049

1

			assert!(top_delegations.total.is_zero());

8050

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8051

1

				RuntimeOrigin::signed(2),

8052

1,

8053

10,

8054

1

				Percent::from_percent(50),

8055

0,

8056

0,

8057

8058

));

8059

1

			let candidate_state =

8060

1

				ParachainStaking::candidate_info(1).expect("just delegated => exists");

8061

1

			assert_eq!(candidate_state.total_counted, 40);

8062

1

			let top_delegations =

8063

1

				ParachainStaking::top_delegations(1).expect("just delegated => exists");

8064

1

			assert_eq!(top_delegations.delegations[0].owner, 2);

8065

1

			assert_eq!(top_delegations.delegations[0].amount, 10);

8066

1

			assert_eq!(top_delegations.total, 10);

8067

1

});

8068

1

8069

8070

#[test]

8071

1

fn test_delegate_with_auto_compound_can_delegate_immediately_after_other_join_candidates() {

8072

1

	ExtBuilder::default()

8073

1

		.with_balances(vec![(1, 20), (2, 20)])

8074

1

		.build()

8075

1

		.execute_with(|| {

8076

1

			assert_ok!(ParachainStaking::join_candidates(

8077

1

				RuntimeOrigin::signed(1),

8078

20,

8079

8080

));

8081

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8082

1

				RuntimeOrigin::signed(2),

8083

1,

8084

20,

8085

1

				Percent::from_percent(50),

8086

0,

8087

0,

8088

8089

));

8090

1

});

8091

1

8092

8093

#[test]

8094

1

fn test_delegate_with_auto_compound_can_delegate_to_other_if_revoking() {

8095

1

	ExtBuilder::default()

8096

1

		.with_balances(vec![(1, 20), (2, 30), (3, 20), (4, 20)])

8097

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20)])

8098

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

8099

1

		.build()

8100

1

		.execute_with(|| {

8101

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8102

1

				RuntimeOrigin::signed(2),

8103

8104

));

8105

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8106

1

				RuntimeOrigin::signed(2),

8107

4,

8108

10,

8109

1

				Percent::from_percent(50),

8110

0,

8111

0,

8112

8113

));

8114

1

});

8115

1

8116

8117

#[test]

8118

1

fn test_delegate_with_auto_compound_cannot_delegate_if_less_than_or_equal_lowest_bottom() {

8119

1

	ExtBuilder::default()

8120

1

		.with_balances(vec![

8121

1

			(1, 20),

8122

1

			(2, 10),

8123

1

			(3, 10),

8124

1

			(4, 10),

8125

1

			(5, 10),

8126

1

			(6, 10),

8127

1

			(7, 10),

8128

1

			(8, 10),

8129

1

			(9, 10),

8130

1

			(10, 10),

8131

1

			(11, 10),

8132

1

])

8133

1

		.with_candidates(vec![(1, 20)])

8134

1

		.with_delegations(vec![

8135

1

			(2, 1, 10),

8136

1

			(3, 1, 10),

8137

1

			(4, 1, 10),

8138

1

			(5, 1, 10),

8139

1

			(6, 1, 10),

8140

1

			(8, 1, 10),

8141

1

			(9, 1, 10),

8142

1

			(10, 1, 10),

8143

1

])

8144

1

		.build()

8145

1

		.execute_with(|| {

8146

1

			assert_noop!(

8147

1

				ParachainStaking::delegate_with_auto_compound(

8148

1

					RuntimeOrigin::signed(11),

8149

1,

8150

10,

8151

1

					Percent::from_percent(50),

8152

8,

8153

0,

8154

8155

),

8156

1

				Error::<Test>::CannotDelegateLessThanOrEqualToLowestBottomWhenFull

8157

);

8158

1

});

8159

1

8160

8161

#[test]

8162

1

fn test_delegate_with_auto_compound_can_delegate_if_greater_than_lowest_bottom() {

8163

1

	ExtBuilder::default()

8164

1

		.with_balances(vec![

8165

1

			(1, 20),

8166

1

			(2, 10),

8167

1

			(3, 10),

8168

1

			(4, 10),

8169

1

			(5, 10),

8170

1

			(6, 10),

8171

1

			(7, 10),

8172

1

			(8, 10),

8173

1

			(9, 10),

8174

1

			(10, 10),

8175

1

			(11, 11),

8176

1

])

8177

1

		.with_candidates(vec![(1, 20)])

8178

1

		.with_delegations(vec![

8179

1

			(2, 1, 10),

8180

1

			(3, 1, 10),

8181

1

			(4, 1, 10),

8182

1

			(5, 1, 10),

8183

1

			(6, 1, 10),

8184

1

			(8, 1, 10),

8185

1

			(9, 1, 10),

8186

1

			(10, 1, 10),

8187

1

])

8188

1

		.build()

8189

1

		.execute_with(|| {

8190

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8191

1

				RuntimeOrigin::signed(11),

8192

1,

8193

11,

8194

1

				Percent::from_percent(50),

8195

8,

8196

0,

8197

8198

));

8199

1

			assert_events_emitted!(Event::DelegationKicked {

8200

1

				delegator: 10,

8201

1

				candidate: 1,

8202

1

				unstaked_amount: 10

8203

1

});

8204

1

			assert_events_emitted!(Event::DelegatorLeft {

8205

1

				delegator: 10,

8206

1

				unstaked_amount: 10

8207

1

});

8208

1

});

8209

1

8210

8211

#[test]

8212

1

fn test_delegate_with_auto_compound_can_still_delegate_to_other_if_leaving() {

8213

1

	ExtBuilder::default()

8214

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20)])

8215

1

		.with_candidates(vec![(1, 20), (3, 20)])

8216

1

		.with_delegations(vec![(2, 1, 10)])

8217

1

		.build()

8218

1

		.execute_with(|| {

8219

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8220

1

				RuntimeOrigin::signed(2),

8221

1,

8222

));

8223

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8224

1

				RuntimeOrigin::signed(2),

8225

3,

8226

10,

8227

1

				Percent::from_percent(50),

8228

0,

8229

0,

8230

8231

			),);

8232

1

});

8233

1

8234

8235

#[test]

8236

1

fn test_delegate_with_auto_compound_cannot_delegate_if_candidate() {

8237

1

	ExtBuilder::default()

8238

1

		.with_balances(vec![(1, 20), (2, 30)])

8239

1

		.with_candidates(vec![(1, 20), (2, 20)])

8240

1

		.build()

8241

1

		.execute_with(|| {

8242

1

			assert_noop!(

8243

1

				ParachainStaking::delegate_with_auto_compound(

8244

1

					RuntimeOrigin::signed(2),

8245

1,

8246

10,

8247

1

					Percent::from_percent(50),

8248

0,

8249

0,

8250

8251

),

8252

1

				Error::<Test>::CandidateExists

8253

);

8254

1

});

8255

1

8256

8257

#[test]

8258

1

fn test_delegate_with_auto_compound_cannot_delegate_if_already_delegated() {

8259

1

	ExtBuilder::default()

8260

1

		.with_balances(vec![(1, 20), (2, 30)])

8261

1

		.with_candidates(vec![(1, 20)])

8262

1

		.with_delegations(vec![(2, 1, 20)])

8263

1

		.build()

8264

1

		.execute_with(|| {

8265

1

			assert_noop!(

8266

1

				ParachainStaking::delegate_with_auto_compound(

8267

1

					RuntimeOrigin::signed(2),

8268

1,

8269

10,

8270

1

					Percent::from_percent(50),

8271

0,

8272

1,

8273

8274

),

8275

1

				Error::<Test>::AlreadyDelegatedCandidate

8276

);

8277

1

});

8278

1

8279

8280

#[test]

8281

1

fn test_delegate_with_auto_compound_cannot_delegate_more_than_max_delegations() {

8282

1

	ExtBuilder::default()

8283

1

		.with_balances(vec![(1, 20), (2, 50), (3, 20), (4, 20), (5, 20), (6, 20)])

8284

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20), (5, 20), (6, 20)])

8285

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10), (2, 4, 10), (2, 5, 10)])

8286

1

		.build()

8287

1

		.execute_with(|| {

8288

1

			assert_noop!(

8289

1

				ParachainStaking::delegate_with_auto_compound(

8290

1

					RuntimeOrigin::signed(2),

8291

6,

8292

10,

8293

1

					Percent::from_percent(50),

8294

0,

8295

0,

8296

8297

),

8298

1

				Error::<Test>::ExceedMaxDelegationsPerDelegator,

8299

);

8300

1

});

8301

1

8302

8303

#[test]

8304

1

fn test_delegate_skips_auto_compound_storage_but_emits_event_for_zero_auto_compound() {

8305

1

	ExtBuilder::default()

8306

1

		.with_balances(vec![(1, 30), (2, 20), (3, 30)])

8307

1

		.with_candidates(vec![(1, 30)])

8308

1

		.with_auto_compounding_delegations(vec![(3, 1, 10, Percent::from_percent(50))])

8309

1

		.build()

8310

1

		.execute_with(|| {

8311

			// We already have an auto-compounding delegation from 3 -> 1, so the hint validation

8312

			// would cause a failure if the auto-compounding isn't skipped properly.

8313

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8314

1

				RuntimeOrigin::signed(2),

8315

1,

8316

10,

8317

1

				Percent::zero(),

8318

1,

8319

0,

8320

0,

8321

));

8322

1

			assert_eq!(1, ParachainStaking::auto_compounding_delegations(&1).len(),);

8323

1

			assert_events_eq!(Event::Delegation {

8324

1

				delegator: 2,

8325

1

				locked_amount: 10,

8326

1

				candidate: 1,

8327

1

				delegator_position: DelegatorAdded::AddedToTop { new_total: 50 },

8328

1

				auto_compound: Percent::zero(),

8329

1

});

8330

1

});

8331

1

8332

8333

#[test]

8334

1

fn test_on_initialize_weights() {

8335

	use crate::mock::System;

8336

	use crate::weights::{SubstrateWeight as PalletWeights, WeightInfo};

8337

	use crate::*;

8338

	use frame_support::{pallet_prelude::*, weights::constants::RocksDbWeight};

8339

8340

	// generate balance, candidate, and delegation vecs to "fill" out delegations

8341

1

	let mut balances = Vec::new();

8342

1

	let mut candidates = Vec::new();

8343

1

	let mut delegations = Vec::new();

8344

8345

30

	for collator in 1..30 {

8346

29

		balances.push((collator, 100));

8347

29

		candidates.push((collator, 10));

8348

29

		let starting_delegator = collator * 1000;

8349

8700

		for delegator in starting_delegator..starting_delegator + 300 {

8350

8700

			balances.push((delegator, 100));

8351

8700

			delegations.push((delegator, collator, 10));

8352

8700

8353

8354

8355

1

	ExtBuilder::default()

8356

1

		.with_balances(balances)

8357

1

		.with_candidates(candidates)

8358

1

		.with_delegations(delegations)

8359

1

		.build()

8360

1

		.execute_with(|| {

8361

1

			let weight = ParachainStaking::on_initialize(1);

8362

8363

			// TODO: build this with proper db reads/writes

8364

1

			assert_eq!(Weight::from_parts(401000000, 0), weight);

8365

8366

			// roll to the end of the round, then run on_init again, we should see round change...

8367

1

			set_author(3, 1, POINTS_PER_ROUND); // must set some points for prepare_staking_payouts

8368

1

			roll_to_round_end(3);

8369

1

			let block = System::block_number() + 1;

8370

1

			let weight = ParachainStaking::on_initialize(block);

8371

8372

			// the total on_init weight during our round change. this number is taken from running

8373

			// the fn with a given weights.rs benchmark, so will need to be updated as benchmarks

8374

			// change.

8375

//

8376

			// following this assertion, we add individual weights together to show that we can

8377

			// derive this number independently.

8378

1

			let expected_on_init = 3018132161;

8379

1

			assert_eq!(Weight::from_parts(expected_on_init, 51554), weight);

8380

8381

			// assemble weight manually to ensure it is well understood

8382

1

			let mut expected_weight = 0u64;

8383

1

			expected_weight += PalletWeights::<Test>::base_on_initialize().ref_time();

8384

1

			expected_weight += PalletWeights::<Test>::prepare_staking_payouts().ref_time();

8385

1

			expected_weight += PalletWeights::<Test>::mark_collators_as_inactive(5).ref_time();

8386

8387

			// TODO: this should be the same as <TotalSelected<Test>>. I believe this relates to

8388

			// genesis building

8389

1

			let num_avg_delegations = 8;

8390

1

			expected_weight += PalletWeights::<Test>::select_top_candidates(

8391

1

				<TotalSelected<Test>>::get(),

8392

1

				num_avg_delegations,

8393

1

8394

1

			.ref_time();

8395

			// SlotProvider read

8396

1

			expected_weight += RocksDbWeight::get().reads_writes(1, 0).ref_time();

8397

			// Round write, done in on-round-change code block inside on_initialize()

8398

1

			expected_weight += RocksDbWeight::get().reads_writes(0, 1).ref_time();

8399

			// more reads/writes manually accounted for for on_finalize

8400

1

			expected_weight += RocksDbWeight::get().reads_writes(4, 3).ref_time();

8401

8402

1

			assert_eq!(Weight::from_parts(expected_weight, 51554), weight);

8403

1

			assert_eq!(expected_on_init, expected_weight); // magic number == independent accounting

8404

1

});

8405

1

8406

8407

#[test]

8408

1

fn test_compute_top_candidates_is_stable() {

8409

1

	ExtBuilder::default()

8410

1

		.with_balances(vec![(1, 30), (2, 30), (3, 30), (4, 30), (5, 30), (6, 30)])

8411

1

		.with_candidates(vec![(1, 30), (2, 30), (3, 30), (4, 30), (5, 30), (6, 30)])

8412

1

		.build()

8413

1

		.execute_with(|| {

8414

			// There are 6 candidates with equal amount, but only 5 can be selected

8415

1

			assert_eq!(ParachainStaking::candidate_pool().0.len(), 6);

8416

1

			assert_eq!(ParachainStaking::total_selected(), 5);

8417

			// Returns the 5 candidates with greater AccountId, because they are iterated in reverse

8418

1

			assert_eq!(

8419

1

				ParachainStaking::compute_top_candidates(),

8420

1

				vec![2, 3, 4, 5, 6]

8421

);

8422

1

});

8423

1

8424

8425

#[test]

8426

1

fn test_linear_inflation_threshold() {

8427

1

	ExtBuilder::default()

8428

1

		.with_balances(vec![(1, 1_000_000_000)])

8429

1

		.build()

8430

1

		.execute_with(|| {

8431

			// Set up initial state

8432

1

			let initial_issuance = Balances::total_issuance();

8433

1

			let threshold = <Test as crate::Config>::LinearInflationThreshold::get();

8434

1

			assert_eq!(threshold, Some(1_200_000_000));

8435

8436

			// When total issuance is below threshold, should use total issuance

8437

1

			let round_below = crate::inflation::round_issuance_range::<Test>(Range {

8438

1

				min: Perbill::from_percent(5),

8439

1

				ideal: Perbill::from_percent(5),

8440

1

				max: Perbill::from_percent(5),

8441

1

});

8442

1

			assert_eq!(round_below.ideal, initial_issuance / 20); // 5% of total issuance

8443

8444

			// Mint tokens to exceed threshold

8445

1

			let _ = Balances::deposit_creating(&1, 500_000_000);

8446

1

			assert!(Balances::total_issuance() > threshold.unwrap());

8447

8448

			// When total issuance exceeds threshold, should use threshold value

8449

1

			let round_above = crate::inflation::round_issuance_range::<Test>(Range {

8450

1

				min: Perbill::from_percent(5),

8451

1

				ideal: Perbill::from_percent(5),

8452

1

				max: Perbill::from_percent(5),

8453

1

});

8454

1

			assert_eq!(round_above.ideal, threshold.unwrap() / 20); // 5% of threshold

8455

1

});

8456

1

8457

8458

#[test]

8459

1

fn delegation_scheduled_requests_stepped_migration_completes_and_preserves_state() {

8460

	use crate::AddGet;

8461

8462

1

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

8463

		type Balance = crate::BalanceOf<Test>;

8464

8465

		#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug)]

8466

		struct LegacyScheduledRequest<AccountId, Balance> {

8467

			delegator: AccountId,

8468

			when_executable: RoundIndex,

8469

			action: DelegationAction<Balance>,

8470

8471

8472

		type OldScheduledRequests = BoundedVec<

8473

			LegacyScheduledRequest<AccountId, Balance>,

8474

			AddGet<

8475

				<Test as crate::Config>::MaxTopDelegationsPerCandidate,

8476

				<Test as crate::Config>::MaxBottomDelegationsPerCandidate,

8477

>,

8478

>;

8479

8480

		// Helper to build the raw storage key for the legacy single-map layout:

8481

		//   prefix ++ Blake2_128(Encode(collator)) ++ Encode(collator)

8482

3

		fn legacy_key_for(prefix: &[u8], collator: &AccountId) -> Vec<u8> {

8483

3

			let mut full = prefix.to_vec();

8484

3

			let encoded_collator = collator.encode();

8485

3

			let hash = blake2_128(&encoded_collator);

8486

3

			full.extend_from_slice(&hash);

8487

3

			full.extend_from_slice(&encoded_collator);

8488

3

			full

8489

3

8490

8491

1

		let prefix = storage_prefix(b"ParachainStaking", b"DelegationScheduledRequests");

8492

8493

		// Build some synthetic legacy data for a few collators.

8494

1

		let scenarios: &[(AccountId, &[(AccountId, u32)])] = &[

8495

1

			(1, &[(10, 2), (11, 1)]),

8496

1

			(2, &[(20, 3)]),

8497

1

			(3, &[(30, 1), (31, 1), (32, 1)]),

8498

1

];

8499

8500

1

		let mut expected_total_requests: u32 = 0;

8501

1

		let mut expected_per_collator: Vec<(AccountId, u32)> = Vec::new();

8502

8503

4

		for (collator, delegators) in scenarios {

8504

3

			let mut legacy_requests: OldScheduledRequests = BoundedVec::default();

8505

3

			let mut distinct_delegators: u32 = 0;

8506

8507

9

			for (delegator, count) in *delegators {

8508

6

				distinct_delegators = distinct_delegators.saturating_add(1);

8509

6

				for _ in 0..*count {

8510

9

					let amount: Balance = 1u32.into();

8511

9

					let request = LegacyScheduledRequest {

8512

9

						delegator: *delegator,

8513

9

						when_executable: 1,

8514

9

						action: DelegationAction::Revoke(amount),

8515

9

};

8516

9

					let push_result = legacy_requests.try_push(request);

8517

9

					assert!(

8518

9

						push_result.is_ok(),

8519

						"legacy_requests should not exceed its bound"

8520

);

8521

9

					expected_total_requests = expected_total_requests.saturating_add(1);

8522

8523

8524

8525

3

			let key = legacy_key_for(&prefix, collator);

8526

3

			let value = legacy_requests.encode();

8527

3

			sp_io::storage::set(&key, &value);

8528

8529

3

			expected_per_collator.push((*collator, distinct_delegators));

8530

8531

8532

		// Drive the stepped migration until completion, checking that each step

8533

		// finishes without error and that the cursor eventually reaches `None`.

8534

1

		let mut cursor: Option<

8535

1

			<MigrateDelegationScheduledRequestsToDoubleMap<Test> as SteppedMigration>::Cursor,

8536

1

		> = None;

8537

8538

1

		for _ in 0..32 {

8539

1

			let mut meter = WeightMeter::new();

8540

1

			let next_cursor = MigrateDelegationScheduledRequestsToDoubleMap::<Test>::step(

8541

1

				cursor.clone(),

8542

1

				&mut meter,

8543

8544

1

			.expect("migration step must not error");

8545

8546

1

			cursor = next_cursor;

8547

8548

1

			if cursor.is_none() {

8549

1

				break;

8550

8551

8552

8553

1

		assert!(

8554

1

			cursor.is_none(),

8555

			"migration should complete in a bounded number of steps"

8556

);

8557

8558

		// Verify that the total number of scheduled requests is preserved.

8559

1

		let mut migrated_total_requests: u32 = 0;

8560

6

		for (_, _, requests) in DelegationScheduledRequests::<Test>::iter() {

8561

6

			migrated_total_requests = migrated_total_requests.saturating_add(requests.len() as u32);

8562

6

8563

1

		assert_eq!(

8564

			migrated_total_requests, expected_total_requests,

8565

			"migration must preserve total number of scheduled delegation requests"

8566

);

8567

8568

		// Verify that the per-collator counters reflect the number of delegator queues.

8569

4

		for (collator, expected_queues) in expected_per_collator {

8570

3

			let counters = DelegationScheduledRequestsPerCollator::<Test>::get(collator);

8571

3

			assert_eq!(

8572

				counters, expected_queues,

8573

				"per-collator queue counter should match number of delegators with requests"

8574

);

8575

8576

1

});

8577

1