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::mock::{

28

	inflation_configs, roll_blocks, roll_to, roll_to_round_begin, roll_to_round_end, set_author,

29

	set_block_author, AccountId, Balances, BlockNumber, ExtBuilder, ParachainStaking, RuntimeEvent,

30

	RuntimeOrigin, Test, POINTS_PER_BLOCK, POINTS_PER_ROUND,

31

};

32

use crate::{

33

	assert_events_emitted, assert_events_emitted_match, assert_events_eq, assert_no_events,

34

	AtStake, Bond, CollatorStatus, DelegationScheduledRequests, DelegatorAdded,

35

	EnableMarkingOffline, Error, Event, InflationDistributionInfo, Range, WasInactive,

36

	DELEGATOR_LOCK_ID,

37

};

38

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

39

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

40

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

41

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

42

// ~~ ROOT ~~

43

44

#[test]

45

1

fn invalid_root_origin_fails() {

46

1

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

47

1

		assert_noop!(

48

1

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

49

1

			sp_runtime::DispatchError::BadOrigin

50

1

);

51

1

		assert_noop!(

52

1

			ParachainStaking::set_collator_commission(

53

1

				RuntimeOrigin::signed(45),

54

1

				Perbill::from_percent(5)

55

1

),

56

1

			sp_runtime::DispatchError::BadOrigin

57

1

);

58

1

		assert_noop!(

59

1

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

60

1

			sp_runtime::DispatchError::BadOrigin

61

1

);

62

1

});

63

1

64

65

// SET TOTAL SELECTED

66

67

#[test]

68

1

fn set_total_selected_event_emits_correctly() {

69

1

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

70

1

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

71

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

72

1

			RuntimeOrigin::root(),

73

1

			7u32

74

1

));

75

1

		roll_blocks(1);

76

1

		assert_ok!(ParachainStaking::set_total_selected(

77

1

			RuntimeOrigin::root(),

78

1

			6u32

79

1

));

80

1

		assert_events_eq!(Event::TotalSelectedSet {

81

1

			old: 5u32,

82

1

			new: 6u32

83

1

});

84

1

});

85

1

86

87

#[test]

88

1

fn set_total_selected_fails_if_above_blocks_per_round() {

89

1

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

90

1

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

91

1

		assert_noop!(

92

1

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

93

1

			Error::<Test>::RoundLengthMustBeGreaterThanTotalSelectedCollators,

94

1

);

95

1

});

96

1

97

98

#[test]

99

1

fn set_total_selected_fails_if_above_max_candidates() {

100

1

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

101

1

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

102

1

		assert_noop!(

103

1

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

104

1

			Error::<Test>::CannotSetAboveMaxCandidates,

105

1

);

106

1

});

107

1

108

109

#[test]

110

1

fn set_total_selected_fails_if_equal_to_blocks_per_round() {

111

1

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

112

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

113

1

			RuntimeOrigin::root(),

114

1

			10u32

115

1

));

116

1

		assert_noop!(

117

1

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

118

1

			Error::<Test>::RoundLengthMustBeGreaterThanTotalSelectedCollators,

119

1

);

120

1

});

121

1

122

123

#[test]

124

1

fn set_total_selected_passes_if_below_blocks_per_round() {

125

1

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

126

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

127

1

			RuntimeOrigin::root(),

128

1

			10u32

129

1

));

130

1

		assert_ok!(ParachainStaking::set_total_selected(

131

1

			RuntimeOrigin::root(),

132

1

			9u32

133

1

));

134

1

});

135

1

136

137

#[test]

138

1

fn set_blocks_per_round_fails_if_below_total_selected() {

139

1

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

140

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

141

1

			RuntimeOrigin::root(),

142

1

			20u32

143

1

));

144

1

		assert_ok!(ParachainStaking::set_total_selected(

145

1

			RuntimeOrigin::root(),

146

1

			10u32

147

1

));

148

1

		assert_noop!(

149

1

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

150

1

			Error::<Test>::RoundLengthMustBeGreaterThanTotalSelectedCollators,

151

1

);

152

1

});

153

1

154

155

#[test]

156

1

fn set_blocks_per_round_fails_if_equal_to_total_selected() {

157

1

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

158

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

159

1

			RuntimeOrigin::root(),

160

1

			10u32

161

1

));

162

1

		assert_ok!(ParachainStaking::set_total_selected(

163

1

			RuntimeOrigin::root(),

164

1

			9u32

165

1

));

166

1

		assert_noop!(

167

1

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

168

1

			Error::<Test>::RoundLengthMustBeGreaterThanTotalSelectedCollators,

169

1

);

170

1

});

171

1

172

173

#[test]

174

1

fn set_blocks_per_round_passes_if_above_total_selected() {

175

1

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

176

1

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

177

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

178

1

			RuntimeOrigin::root(),

179

1

			6u32

180

1

));

181

1

});

182

1

183

184

#[test]

185

1

fn set_total_selected_storage_updates_correctly() {

186

1

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

187

1

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

188

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

189

1

			RuntimeOrigin::root(),

190

1

			10u32

191

1

));

192

193

1

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

194

1

		assert_ok!(ParachainStaking::set_total_selected(

195

1

			RuntimeOrigin::root(),

196

1

			6u32

197

1

));

198

1

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

199

1

});

200

1

201

202

#[test]

203

1

fn cannot_set_total_selected_to_current_total_selected() {

204

1

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

205

1

		assert_noop!(

206

1

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

207

1

			Error::<Test>::NoWritingSameValue

208

1

);

209

1

});

210

1

211

212

#[test]

213

1

fn cannot_set_total_selected_below_module_min() {

214

1

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

215

1

		assert_noop!(

216

1

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

217

1

			Error::<Test>::CannotSetBelowMin

218

1

);

219

1

});

220

1

221

222

// SET COLLATOR COMMISSION

223

224

#[test]

225

1

fn set_collator_commission_event_emits_correctly() {

226

1

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

227

1

		assert_ok!(ParachainStaking::set_collator_commission(

228

1

			RuntimeOrigin::root(),

229

1

			Perbill::from_percent(5)

230

1

));

231

1

		assert_events_eq!(Event::CollatorCommissionSet {

232

1

			old: Perbill::from_percent(20),

233

1

			new: Perbill::from_percent(5),

234

1

});

235

1

});

236

1

237

238

#[test]

239

1

fn set_collator_commission_storage_updates_correctly() {

240

1

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

241

1

		assert_eq!(

242

1

			ParachainStaking::collator_commission(),

243

1

			Perbill::from_percent(20)

244

1

);

245

1

		assert_ok!(ParachainStaking::set_collator_commission(

246

1

			RuntimeOrigin::root(),

247

1

			Perbill::from_percent(5)

248

1

));

249

1

		assert_eq!(

250

1

			ParachainStaking::collator_commission(),

251

1

			Perbill::from_percent(5)

252

1

);

253

1

});

254

1

255

256

#[test]

257

1

fn cannot_set_collator_commission_to_current_collator_commission() {

258

1

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

259

1

		assert_noop!(

260

1

			ParachainStaking::set_collator_commission(

261

1

				RuntimeOrigin::root(),

262

1

				Perbill::from_percent(20)

263

1

),

264

1

			Error::<Test>::NoWritingSameValue

265

1

);

266

1

});

267

1

268

269

// SET BLOCKS PER ROUND

270

271

#[test]

272

1

fn set_blocks_per_round_event_emits_correctly() {

273

1

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

274

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

275

1

			RuntimeOrigin::root(),

276

1

			6u32

277

1

));

278

1

		assert_events_eq!(Event::BlocksPerRoundSet {

279

1

			current_round: 1,

280

1

			first_block: 0,

281

1

			old: 5,

282

1

			new: 6,

283

1

			new_per_round_inflation_min: Perbill::from_parts(463),

284

1

			new_per_round_inflation_ideal: Perbill::from_parts(463),

285

1

			new_per_round_inflation_max: Perbill::from_parts(463),

286

1

});

287

1

});

288

1

289

290

#[test]

291

1

fn set_blocks_per_round_storage_updates_correctly() {

292

1

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

293

1

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

294

1

		assert_ok!(ParachainStaking::set_blocks_per_round(

295

1

			RuntimeOrigin::root(),

296

1

			6u32

297

1

));

298

1

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

299

1

});

300

1

301

302

#[test]

303

1

fn cannot_set_blocks_per_round_below_module_min() {

304

1

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

305

1

		assert_noop!(

306

1

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

307

1

			Error::<Test>::CannotSetBelowMin

308

1

);

309

1

});

310

1

311

312

#[test]

313

1

fn cannot_set_blocks_per_round_to_current_blocks_per_round() {

314

1

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

315

1

		assert_noop!(

316

1

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

317

1

			Error::<Test>::NoWritingSameValue

318

1

);

319

1

});

320

1

321

322

#[test]

323

1

fn round_immediately_jumps_if_current_duration_exceeds_new_blocks_per_round() {

324

1

	ExtBuilder::default()

325

1

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

326

1

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

327

1

		.build()

328

1

		.execute_with(|| {

329

1

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

330

1

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

331

1

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

332

1

			assert_ok!(ParachainStaking::set_blocks_per_round(

333

1

				RuntimeOrigin::root(),

334

1

				10u32

335

1

));

336

337

1

			roll_to(10);

338

1

			assert_events_emitted!(Event::NewRound {

339

1

				starting_block: 10,

340

1

				round: 2,

341

1

				selected_collators_number: 1,

342

1

				total_balance: 20

343

1

			},);

344

1

			roll_to(17);

345

1

			assert_ok!(ParachainStaking::set_blocks_per_round(

346

1

				RuntimeOrigin::root(),

347

1

				6u32

348

1

));

349

1

			roll_to(18);

350

1

			assert_events_emitted!(Event::NewRound {

351

1

				starting_block: 18,

352

1

				round: 3,

353

1

				selected_collators_number: 1,

354

1

				total_balance: 20

355

1

});

356

1

});

357

1

358

359

// ~~ MONETARY GOVERNANCE ~~

360

361

#[test]

362

1

fn invalid_monetary_origin_fails() {

363

1

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

364

1

		assert_noop!(

365

1

			ParachainStaking::set_staking_expectations(

366

1

				RuntimeOrigin::signed(45),

367

1

				Range {

368

1

					min: 3u32.into(),

369

1

					ideal: 4u32.into(),

370

1

					max: 5u32.into()

371

1

372

1

),

373

1

			sp_runtime::DispatchError::BadOrigin

374

1

);

375

1

		assert_noop!(

376

1

			ParachainStaking::set_inflation(

377

1

				RuntimeOrigin::signed(45),

378

1

				Range {

379

1

					min: Perbill::from_percent(3),

380

1

					ideal: Perbill::from_percent(4),

381

1

					max: Perbill::from_percent(5)

382

1

383

1

),

384

1

			sp_runtime::DispatchError::BadOrigin

385

1

);

386

1

		assert_noop!(

387

1

			ParachainStaking::set_inflation(

388

1

				RuntimeOrigin::signed(45),

389

1

				Range {

390

1

					min: Perbill::from_percent(3),

391

1

					ideal: Perbill::from_percent(4),

392

1

					max: Perbill::from_percent(5)

393

1

394

1

),

395

1

			sp_runtime::DispatchError::BadOrigin

396

1

);

397

1

		assert_noop!(

398

1

			ParachainStaking::set_parachain_bond_account(RuntimeOrigin::signed(45), 11),

399

1

			sp_runtime::DispatchError::BadOrigin

400

1

);

401

1

		assert_noop!(

402

1

			ParachainStaking::set_parachain_bond_reserve_percent(

403

1

				RuntimeOrigin::signed(45),

404

1

				Percent::from_percent(2)

405

1

),

406

1

			sp_runtime::DispatchError::BadOrigin

407

1

);

408

1

});

409

1

410

411

// SET STAKING EXPECTATIONS

412

413

#[test]

414

1

fn set_staking_event_emits_event_correctly() {

415

1

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

416

1

		// valid call succeeds

417

1

		assert_ok!(ParachainStaking::set_staking_expectations(

418

1

			RuntimeOrigin::root(),

419

1

			Range {

420

1

				min: 3u128,

421

1

				ideal: 4u128,

422

1

				max: 5u128,

423

1

424

1

));

425

1

		assert_events_eq!(Event::StakeExpectationsSet {

426

1

			expect_min: 3u128,

427

1

			expect_ideal: 4u128,

428

1

			expect_max: 5u128,

429

1

});

430

1

});

431

1

432

433

#[test]

434

1

fn set_staking_updates_storage_correctly() {

435

1

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

436

1

		assert_eq!(

437

1

			ParachainStaking::inflation_config().expect,

438

1

			Range {

439

1

				min: 700,

440

1

				ideal: 700,

441

1

				max: 700

442

1

443

1

);

444

1

		assert_ok!(ParachainStaking::set_staking_expectations(

445

1

			RuntimeOrigin::root(),

446

1

			Range {

447

1

				min: 3u128,

448

1

				ideal: 4u128,

449

1

				max: 5u128,

450

1

451

1

));

452

1

		assert_eq!(

453

1

			ParachainStaking::inflation_config().expect,

454

1

			Range {

455

1

				min: 3u128,

456

1

				ideal: 4u128,

457

1

				max: 5u128

458

1

459

1

);

460

1

});

461

1

462

463

#[test]

464

1

fn cannot_set_invalid_staking_expectations() {

465

1

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

466

1

		// invalid call fails

467

1

		assert_noop!(

468

1

			ParachainStaking::set_staking_expectations(

469

1

				RuntimeOrigin::root(),

470

1

				Range {

471

1

					min: 5u128,

472

1

					ideal: 4u128,

473

1

					max: 3u128

474

1

475

1

),

476

1

			Error::<Test>::InvalidSchedule

477

1

);

478

1

});

479

1

480

481

#[test]

482

1

fn cannot_set_same_staking_expectations() {

483

1

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

484

1

		assert_ok!(ParachainStaking::set_staking_expectations(

485

1

			RuntimeOrigin::root(),

486

1

			Range {

487

1

				min: 3u128,

488

1

				ideal: 4u128,

489

1

				max: 5u128

490

1

491

1

));

492

1

		assert_noop!(

493

1

			ParachainStaking::set_staking_expectations(

494

1

				RuntimeOrigin::root(),

495

1

				Range {

496

1

					min: 3u128,

497

1

					ideal: 4u128,

498

1

					max: 5u128

499

1

500

1

),

501

1

			Error::<Test>::NoWritingSameValue

502

1

);

503

1

});

504

1

505

506

// SET INFLATION

507

508

#[test]

509

1

fn set_inflation_event_emits_correctly() {

510

1

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

511

1

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

512

1

			Perbill::from_percent(3),

513

1

			Perbill::from_percent(4),

514

1

			Perbill::from_percent(5),

515

1

);

516

1

		assert_ok!(ParachainStaking::set_inflation(

517

1

			RuntimeOrigin::root(),

518

1

			Range { min, ideal, max }

519

1

));

520

1

		assert_events_eq!(Event::InflationSet {

521

1

			annual_min: min,

522

1

			annual_ideal: ideal,

523

1

			annual_max: max,

524

1

			round_min: Perbill::from_parts(29),

525

1

			round_ideal: Perbill::from_parts(38),

526

1

			round_max: Perbill::from_parts(47),

527

1

});

528

1

});

529

1

530

531

#[test]

532

1

fn set_inflation_storage_updates_correctly() {

533

1

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

534

1

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

535

1

			Perbill::from_percent(3),

536

1

			Perbill::from_percent(4),

537

1

			Perbill::from_percent(5),

538

1

);

539

1

		assert_eq!(

540

1

			ParachainStaking::inflation_config().annual,

541

1

			Range {

542

1

				min: Perbill::from_percent(50),

543

1

				ideal: Perbill::from_percent(50),

544

1

				max: Perbill::from_percent(50)

545

1

546

1

);

547

1

		assert_eq!(

548

1

			ParachainStaking::inflation_config().round,

549

1

			Range {

550

1

				min: Perbill::from_percent(5),

551

1

				ideal: Perbill::from_percent(5),

552

1

				max: Perbill::from_percent(5)

553

1

554

1

);

555

1

		assert_ok!(ParachainStaking::set_inflation(

556

1

			RuntimeOrigin::root(),

557

1

			Range { min, ideal, max }

558

1

		),);

559

1

		assert_eq!(

560

1

			ParachainStaking::inflation_config().annual,

561

1

			Range { min, ideal, max }

562

1

);

563

1

		assert_eq!(

564

1

			ParachainStaking::inflation_config().round,

565

1

			Range {

566

1

				min: Perbill::from_parts(29),

567

1

				ideal: Perbill::from_parts(38),

568

1

				max: Perbill::from_parts(47)

569

1

570

1

);

571

1

});

572

1

573

574

#[test]

575

1

fn cannot_set_invalid_inflation() {

576

1

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

577

1

		assert_noop!(

578

1

			ParachainStaking::set_inflation(

579

1

				RuntimeOrigin::root(),

580

1

				Range {

581

1

					min: Perbill::from_percent(5),

582

1

					ideal: Perbill::from_percent(4),

583

1

					max: Perbill::from_percent(3)

584

1

585

1

),

586

1

			Error::<Test>::InvalidSchedule

587

1

);

588

1

});

589

1

590

591

#[test]

592

1

fn cannot_set_same_inflation() {

593

1

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

594

1

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

595

1

			Perbill::from_percent(3),

596

1

			Perbill::from_percent(4),

597

1

			Perbill::from_percent(5),

598

1

);

599

1

		assert_ok!(ParachainStaking::set_inflation(

600

1

			RuntimeOrigin::root(),

601

1

			Range { min, ideal, max }

602

1

		),);

603

1

		assert_noop!(

604

1

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

605

1

			Error::<Test>::NoWritingSameValue

606

1

);

607

1

});

608

1

609

610

// SET PARACHAIN BOND ACCOUNT

611

612

#[test]

613

1

fn set_parachain_bond_account_event_emits_correctly() {

614

1

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

615

1

		assert_ok!(ParachainStaking::set_parachain_bond_account(

616

1

			RuntimeOrigin::root(),

617

1

618

1

));

619

1

		assert_events_eq!(Event::InflationDistributionConfigUpdated {

620

1

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

621

1

			new: inflation_configs(11, 30, 0, 0),

622

1

});

623

1

});

624

1

625

626

#[test]

627

1

fn set_parachain_bond_account_storage_updates_correctly() {

628

1

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

629

1

		assert_eq!(

630

1

			ParachainStaking::inflation_distribution_info().0[0].account,

631

1

632

1

);

633

1

		assert_ok!(ParachainStaking::set_parachain_bond_account(

634

1

			RuntimeOrigin::root(),

635

1

636

1

));

637

1

		assert_eq!(

638

1

			ParachainStaking::inflation_distribution_info().0[0].account,

639

1

640

1

);

641

1

});

642

1

643

644

// SET PARACHAIN BOND RESERVE PERCENT

645

646

#[test]

647

1

fn set_parachain_bond_reserve_percent_event_emits_correctly() {

648

1

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

649

1

		assert_ok!(ParachainStaking::set_parachain_bond_reserve_percent(

650

1

			RuntimeOrigin::root(),

651

1

			Percent::from_percent(50)

652

1

));

653

1

		assert_events_eq!(Event::InflationDistributionConfigUpdated {

654

1

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

655

1

			new: inflation_configs(0, 50, 0, 0),

656

1

});

657

1

});

658

1

659

660

#[test]

661

1

fn set_parachain_bond_reserve_percent_storage_updates_correctly() {

662

1

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

663

1

		assert_eq!(

664

1

			ParachainStaking::inflation_distribution_info().0[0].percent,

665

1

			Percent::from_percent(30)

666

1

);

667

1

		assert_ok!(ParachainStaking::set_parachain_bond_reserve_percent(

668

1

			RuntimeOrigin::root(),

669

1

			Percent::from_percent(50)

670

1

));

671

1

		assert_eq!(

672

1

			ParachainStaking::inflation_distribution_info().0[0].percent,

673

1

			Percent::from_percent(50)

674

1

);

675

1

});

676

1

677

678

#[test]

679

1

fn cannot_set_same_parachain_bond_reserve_percent() {

680

1

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

681

1

		assert_noop!(

682

1

			ParachainStaking::set_parachain_bond_reserve_percent(

683

1

				RuntimeOrigin::root(),

684

1

				Percent::from_percent(30)

685

1

),

686

1

			Error::<Test>::NoWritingSameValue

687

1

);

688

1

});

689

1

690

691

// Set Inflation Distribution Config

692

693

#[test]

694

1

fn set_inflation_distribution_config_fails_with_normal_origin() {

695

1

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

696

1

		assert_noop!(

697

1

			ParachainStaking::set_inflation_distribution_config(

698

1

				RuntimeOrigin::signed(45),

699

1

				inflation_configs(1, 30, 2, 20)

700

1

),

701

1

			sp_runtime::DispatchError::BadOrigin,

702

1

);

703

1

});

704

1

705

706

#[test]

707

1

fn set_inflation_distribution_config_event_emits_correctly() {

708

1

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

709

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

710

1

			RuntimeOrigin::root(),

711

1

			inflation_configs(1, 30, 2, 20),

712

1

));

713

1

		assert_events_eq!(Event::InflationDistributionConfigUpdated {

714

1

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

715

1

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

716

1

});

717

1

		roll_blocks(1);

718

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

719

1

			RuntimeOrigin::root(),

720

1

			inflation_configs(5, 10, 6, 5),

721

1

));

722

1

		assert_events_eq!(Event::InflationDistributionConfigUpdated {

723

1

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

724

1

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

725

1

});

726

1

});

727

1

728

729

#[test]

730

1

fn set_inflation_distribution_config_storage_updates_correctly() {

731

1

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

732

1

		assert_eq!(

733

1

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

734

1

			inflation_configs(0, 30, 0, 0),

735

1

);

736

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

737

1

			RuntimeOrigin::root(),

738

1

			inflation_configs(5, 10, 6, 5),

739

1

));

740

1

		assert_eq!(

741

1

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

742

1

			inflation_configs(5, 10, 6, 5),

743

1

);

744

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

745

1

			RuntimeOrigin::root(),

746

1

			inflation_configs(1, 30, 2, 20),

747

1

));

748

1

		assert_eq!(

749

1

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

750

1

			inflation_configs(1, 30, 2, 20),

751

1

);

752

1

});

753

1

754

755

#[test]

756

1

fn cannot_set_same_inflation_distribution_config() {

757

1

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

758

1

		assert_ok!(ParachainStaking::set_inflation_distribution_config(

759

1

			RuntimeOrigin::root(),

760

1

			inflation_configs(1, 30, 2, 20),

761

1

));

762

1

		assert_noop!(

763

1

			ParachainStaking::set_inflation_distribution_config(

764

1

				RuntimeOrigin::root(),

765

1

				inflation_configs(1, 30, 2, 20)

766

1

),

767

1

			Error::<Test>::NoWritingSameValue,

768

1

);

769

1

});

770

1

771

772

#[test]

773

1

fn sum_of_inflation_distribution_config_percentages_must_lte_100() {

774

1

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

775

1

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

776

1

			(20, 90),

777

1

			(90, 20),

778

1

			(50, 51),

779

1

			(100, 1),

780

1

			(1, 100),

781

1

			(55, 55),

782

1

			(2, 99),

783

1

			(100, 100),

784

1

];

785

786

9

		for (pbr_percentage, treasury_percentage) in invalid_values {

787

8

			assert_noop!(

788

8

				ParachainStaking::set_inflation_distribution_config(

789

8

					RuntimeOrigin::root(),

790

8

					inflation_configs(1, pbr_percentage, 2, treasury_percentage),

791

8

),

792

8

				Error::<Test>::TotalInflationDistributionPercentExceeds100,

793

8

);

794

795

796

1

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

797

1

			(0, 100),

798

1

			(100, 0),

799

1

			(0, 0),

800

1

			(100, 0),

801

1

			(0, 100),

802

1

			(50, 50),

803

1

			(1, 99),

804

1

			(99, 1),

805

1

			(1, 1),

806

1

			(10, 20),

807

1

			(34, 32),

808

1

			(15, 10),

809

1

];

810

811

13

		for (pbr_percentage, treasury_percentage) in valid_values {

812

12

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

813

12

				RuntimeOrigin::root(),

814

12

				inflation_configs(1, pbr_percentage, 2, treasury_percentage),

815

12

));

816

817

1

});

818

1

819

820

// ~~ PUBLIC ~~

821

822

// JOIN CANDIDATES

823

824

#[test]

825

1

fn join_candidates_event_emits_correctly() {

826

1

	ExtBuilder::default()

827

1

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

828

1

		.build()

829

1

		.execute_with(|| {

830

1

			assert_ok!(ParachainStaking::join_candidates(

831

1

				RuntimeOrigin::signed(1),

832

1

				10u128,

833

1

				0u32

834

1

));

835

1

			assert_events_eq!(Event::JoinedCollatorCandidates {

836

1

				account: 1,

837

1

				amount_locked: 10u128,

838

1

				new_total_amt_locked: 10u128,

839

1

});

840

1

});

841

1

842

843

#[test]

844

1

fn join_candidates_reserves_balance() {

845

1

	ExtBuilder::default()

846

1

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

847

1

		.build()

848

1

		.execute_with(|| {

849

1

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

850

1

			assert_ok!(ParachainStaking::join_candidates(

851

1

				RuntimeOrigin::signed(1),

852

1

				10u128,

853

1

				0u32

854

1

));

855

1

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

856

1

});

857

1

858

859

#[test]

860

1

fn join_candidates_increases_total_staked() {

861

1

	ExtBuilder::default()

862

1

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

863

1

		.build()

864

1

		.execute_with(|| {

865

1

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

866

1

			assert_ok!(ParachainStaking::join_candidates(

867

1

				RuntimeOrigin::signed(1),

868

1

				10u128,

869

1

				0u32

870

1

));

871

1

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

872

1

});

873

1

874

875

#[test]

876

1

fn join_candidates_creates_candidate_state() {

877

1

	ExtBuilder::default()

878

1

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

879

1

		.build()

880

1

		.execute_with(|| {

881

1

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

882

1

			assert_ok!(ParachainStaking::join_candidates(

883

1

				RuntimeOrigin::signed(1),

884

1

				10u128,

885

1

				0u32

886

1

));

887

1

			let candidate_state =

888

1

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

889

1

			assert_eq!(candidate_state.bond, 10u128);

890

1

});

891

1

892

893

#[test]

894

1

fn join_candidates_adds_to_candidate_pool() {

895

1

	ExtBuilder::default()

896

1

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

897

1

		.build()

898

1

		.execute_with(|| {

899

1

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

900

1

			assert_ok!(ParachainStaking::join_candidates(

901

1

				RuntimeOrigin::signed(1),

902

1

				10u128,

903

1

				0u32

904

1

));

905

1

			let candidate_pool = ParachainStaking::candidate_pool();

906

1

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

907

1

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

908

1

});

909

1

910

911

#[test]

912

1

fn cannot_join_candidates_if_candidate() {

913

1

	ExtBuilder::default()

914

1

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

915

1

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

916

1

		.build()

917

1

		.execute_with(|| {

918

1

			assert_noop!(

919

1

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

920

1

				Error::<Test>::CandidateExists

921

1

);

922

1

});

923

1

924

925

#[test]

926

1

fn cannot_join_candidates_if_delegator() {

927

1

	ExtBuilder::default()

928

1

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

929

1

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

930

1

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

931

1

		.build()

932

1

		.execute_with(|| {

933

1

			assert_noop!(

934

1

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

935

1

				Error::<Test>::DelegatorExists

936

1

);

937

1

});

938

1

939

940

#[test]

941

1

fn cannot_join_candidates_without_min_bond() {

942

1

	ExtBuilder::default()

943

1

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

944

1

		.build()

945

1

		.execute_with(|| {

946

1

			assert_noop!(

947

1

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

948

1

				Error::<Test>::CandidateBondBelowMin

949

1

);

950

1

});

951

1

952

953

#[test]

954

1

fn can_force_join_candidates_without_min_bond() {

955

1

	ExtBuilder::default()

956

1

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

957

1

		.build()

958

1

		.execute_with(|| {

959

1

			assert_ok!(ParachainStaking::force_join_candidates(

960

1

				RuntimeOrigin::root(),

961

1

1,

962

1

9,

963

1

				100u32

964

1

));

965

1

			assert_events_eq!(Event::JoinedCollatorCandidates {

966

1

				account: 1,

967

1

				amount_locked: 9u128,

968

1

				new_total_amt_locked: 9u128,

969

1

});

970

1

});

971

1

972

973

#[test]

974

1

fn cannot_join_candidates_with_more_than_available_balance() {

975

1

	ExtBuilder::default()

976

1

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

977

1

		.build()

978

1

		.execute_with(|| {

979

1

			assert_noop!(

980

1

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

981

1

				DispatchError::Module(ModuleError {

982

1

					index: 2,

983

1

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

984

1

					message: Some("InsufficientBalance")

985

1

})

986

1

);

987

1

});

988

1

989

990

#[test]

991

1

fn insufficient_join_candidates_weight_hint_fails() {

992

1

	ExtBuilder::default()

993

1

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

994

1

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

995

1

		.build()

996

1

		.execute_with(|| {

997

6

			for i in 0..5 {

998

5

				assert_noop!(

999

5

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

1000

5

					Error::<Test>::TooLowCandidateCountWeightHintJoinCandidates

1001

5

);

1002

1003

1

});

1004

1

1005

1006

#[test]

1007

1

fn sufficient_join_candidates_weight_hint_succeeds() {

1008

1

	ExtBuilder::default()

1009

1

		.with_balances(vec![

1010

1

			(1, 20),

1011

1

			(2, 20),

1012

1

			(3, 20),

1013

1

			(4, 20),

1014

1

			(5, 20),

1015

1

			(6, 20),

1016

1

			(7, 20),

1017

1

			(8, 20),

1018

1

			(9, 20),

1019

1

])

1020

1

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

1021

1

		.build()

1022

1

		.execute_with(|| {

1023

1

			let mut count = 5u32;

1024

5

			for i in 6..10 {

1025

4

				assert_ok!(ParachainStaking::join_candidates(

1026

4

					RuntimeOrigin::signed(i),

1027

4

20,

1028

4

					count

1029

4

));

1030

4

				count += 1u32;

1031

1032

1

});

1033

1

1034

1035

#[test]

1036

1

fn join_candidates_fails_if_above_max_candidate_count() {

1037

1

	let mut candidates = vec![];

1038

200

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

1039

200

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

1040

200

1041

1042

1

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

1043

1

	let mut balances = candidates.clone();

1044

1

	balances.push((new_candidate, 100));

1045

1

1046

1

	ExtBuilder::default()

1047

1

		.with_balances(balances)

1048

1

		.with_candidates(candidates)

1049

1

		.build()

1050

1

		.execute_with(|| {

1051

1

			assert_noop!(

1052

1

				ParachainStaking::join_candidates(

1053

1

					RuntimeOrigin::signed(new_candidate),

1054

1

80,

1055

1

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

1056

1

),

1057

1

				Error::<Test>::CandidateLimitReached,

1058

1

);

1059

1

});

1060

1

1061

1062

// SCHEDULE LEAVE CANDIDATES

1063

1064

#[test]

1065

1

fn leave_candidates_event_emits_correctly() {

1066

1

	ExtBuilder::default()

1067

1

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

1068

1

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

1069

1

		.build()

1070

1

		.execute_with(|| {

1071

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1072

1

				RuntimeOrigin::signed(1),

1073

1

				1u32

1074

1

));

1075

1

			assert_events_eq!(Event::CandidateScheduledExit {

1076

1

				exit_allowed_round: 1,

1077

1

				candidate: 1,

1078

1

				scheduled_exit: 3

1079

1

});

1080

1

});

1081

1

1082

1083

#[test]

1084

1

fn leave_candidates_removes_candidate_from_candidate_pool() {

1085

1

	ExtBuilder::default()

1086

1

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

1087

1

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

1088

1

		.build()

1089

1

		.execute_with(|| {

1090

1

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

1091

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1092

1

				RuntimeOrigin::signed(1),

1093

1

				1u32

1094

1

));

1095

1

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

1096

1

});

1097

1

1098

1099

#[test]

1100

1

fn cannot_leave_candidates_if_not_candidate() {

1101

1

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

1102

1

		assert_noop!(

1103

1

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

1104

1

			Error::<Test>::CandidateDNE

1105

1

);

1106

1

});

1107

1

1108

1109

#[test]

1110

1

fn cannot_leave_candidates_if_already_leaving_candidates() {

1111

1

	ExtBuilder::default()

1112

1

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

1113

1

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

1114

1

		.build()

1115

1

		.execute_with(|| {

1116

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1117

1

				RuntimeOrigin::signed(1),

1118

1

				1u32

1119

1

));

1120

1

			assert_noop!(

1121

1

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

1122

1

				Error::<Test>::CandidateAlreadyLeaving

1123

1

);

1124

1

});

1125

1

1126

1127

#[test]

1128

1

fn insufficient_leave_candidates_weight_hint_fails() {

1129

1

	ExtBuilder::default()

1130

1

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

1131

1

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

1132

1

		.build()

1133

1

		.execute_with(|| {

1134

6

			for i in 1..6 {

1135

5

				assert_noop!(

1136

5

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

1137

5

					Error::<Test>::TooLowCandidateCountToLeaveCandidates

1138

5

);

1139

1140

1

});

1141

1

1142

1143

#[test]

1144

1

fn enable_marking_offline_works() {

1145

1

	ExtBuilder::default()

1146

1

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

1147

1

		.build()

1148

1

		.execute_with(|| {

1149

1

			assert_ok!(ParachainStaking::enable_marking_offline(

1150

1

				RuntimeOrigin::root(),

1151

1

				true

1152

1

));

1153

1

			assert!(ParachainStaking::marking_offline());

1154

1155

			// Set to false now

1156

1

			assert_ok!(ParachainStaking::enable_marking_offline(

1157

1

				RuntimeOrigin::root(),

1158

1

				false

1159

1

));

1160

1

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

1161

1

});

1162

1

1163

1164

#[test]

1165

1

fn enable_marking_offline_fails_bad_origin() {

1166

1

	ExtBuilder::default()

1167

1

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

1168

1

		.build()

1169

1

		.execute_with(|| {

1170

1

			assert_noop!(

1171

1

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

1172

1

				sp_runtime::DispatchError::BadOrigin

1173

1

);

1174

1

});

1175

1

1176

1177

#[test]

1178

1

fn was_inactive_is_cleaned_up_after_max_offline_rounds() {

1179

	const ACTIVE_COLLATOR: AccountId = 1;

1180

	const INACTIVE_COLLATOR: AccountId = 2;

1181

1182

1

	ExtBuilder::default()

1183

1

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

1184

1

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

1185

1

		.build()

1186

1

		.execute_with(|| {

1187

1

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

1188

1

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

1189

1190

			// ACTIVE_COLLATOR authors all the blocks

1191

1

			set_block_author(ACTIVE_COLLATOR);

1192

1

1193

1

			// Round 2

1194

1

			roll_to_round_begin(2);

1195

1

1196

1

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

1197

1

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

1198

1199

1

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

1200

1

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

1201

1202

			// Round 3

1203

1

			roll_to_round_begin(3);

1204

1

1205

1

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

1206

1

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

1207

1208

1

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

1209

1

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

1210

1211

			// End of round 3

1212

1

			roll_to_round_end(3);

1213

1

1214

1

			assert!(

1215

1

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

1216

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

1217

);

1218

1

			assert!(

1219

1

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

1220

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

1221

);

1222

1223

1

			assert!(

1224

1

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

1225

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

1226

);

1227

1

			assert!(

1228

1

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

1229

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

1230

);

1231

1232

			// Round 4

1233

1

			roll_to_round_end(4);

1234

1

1235

1

			assert!(

1236

1

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

1237

				"Round 1 WasInactive should be cleaned up after MaxOfflineRounds"

1238

);

1239

1

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

1240

1

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

1241

1

});

1242

1

1243

1244

#[test]

1245

1

fn notify_inactive_collator_works() {

1246

	const INACTIVE_COLLATOR: AccountId = 1;

1247

	const ACTIVE_COLLATOR: AccountId = 2;

1248

1249

1

	ExtBuilder::default()

1250

1

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

1251

1

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

1252

1

		.build()

1253

1

		.execute_with(|| {

1254

1

			// Enable killswitch

1255

1

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

1256

1

1257

1

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

1258

1

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

1259

1260

			// Round 2 - INACTIVE_COLLATOR authors blocks

1261

1

			set_block_author(INACTIVE_COLLATOR);

1262

1

			roll_to_round_begin(2);

1263

1

1264

1

			// Change block author

1265

1

			set_block_author(ACTIVE_COLLATOR);

1266

1

1267

1

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

1268

1

			roll_to_round_begin(4);

1269

1

			roll_blocks(1);

1270

1

1271

1

			// On round 4 notify inactive collator

1272

1

			assert_ok!(ParachainStaking::notify_inactive_collator(

1273

1

				RuntimeOrigin::signed(1),

1274

1

				INACTIVE_COLLATOR

1275

1

));

1276

1277

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

1278

1

			assert_events_eq!(Event::CandidateWentOffline {

1279

1

				candidate: INACTIVE_COLLATOR

1280

1

			},);

1281

1

});

1282

1

1283

1284

#[test]

1285

1

fn notify_inactive_collator_succeeds_even_after_rewards_are_distributed() {

1286

	const INACTIVE_COLLATOR: AccountId = 1;

1287

	const ACTIVE_COLLATOR: AccountId = 2;

1288

1289

1

	ExtBuilder::default()

1290

1

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

1291

1

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

1292

1

		.build()

1293

1

		.execute_with(|| {

1294

1

			// Enable killswitch

1295

1

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

1296

1

1297

1

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

1298

1

			// can be distributed before the end of a round

1299

1

			assert_ok!(ParachainStaking::set_blocks_per_round(

1300

1

				RuntimeOrigin::root(),

1301

1

				6u32

1302

1

));

1303

1304

			// ACTIVE_COLLATOR authors all the blocks while INACTIVE_COLLATOR stays inactive

1305

1

			set_block_author(ACTIVE_COLLATOR);

1306

1

1307

1

			// Round 2

1308

1

			roll_to_round_begin(2);

1309

1

			roll_blocks(1);

1310

1

1311

1

			// INACTIVE_COLLATOR has a stake in round 1

1312

1

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

1313

1314

			// Round 3

1315

1

			roll_to_round_begin(3);

1316

1

			roll_blocks(1);

1317

1

1318

1

			// INACTIVE_COLLATOR has a stake in round 2

1319

1

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

1320

1321

			// End of round 3

1322

1

			roll_to_round_end(3);

1323

1

1324

1

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

1325

1

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

1326

1327

			// Call 'notify_inactive_collator' extrinsic on INACTIVE_COLLATOR

1328

1

			assert_ok!(ParachainStaking::notify_inactive_collator(

1329

1

				RuntimeOrigin::signed(1),

1330

1

				INACTIVE_COLLATOR

1331

1

));

1332

1333

1

			assert_events_eq!(

1334

1

				Event::Rewarded {

1335

1

					account: 2,

1336

1

					rewards: 0,

1337

1

},

1338

1

				Event::CandidateWentOffline {

1339

1

					candidate: INACTIVE_COLLATOR

1340

1

},

1341

1

);

1342

1

});

1343

1

1344

1345

#[test]

1346

1

fn notify_inactive_collator_fails_too_low_collator_count() {

1347

1

	ExtBuilder::default()

1348

1

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

1349

1

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

1350

1

		.build()

1351

1

		.execute_with(|| {

1352

1

			// Enable killswitch

1353

1

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

1354

1

1355

1

			// Round 4

1356

1

			roll_to_round_begin(4);

1357

1

			roll_blocks(1);

1358

1

1359

1

			// Call 'notify_inactive_collator' extrinsic

1360

1

			assert_noop!(

1361

1

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

1362

1

				Error::<Test>::TooLowCollatorCountToNotifyAsInactive

1363

1

);

1364

1

});

1365

1

1366

1367

#[test]

1368

1

fn notify_inactive_collator_fails_candidate_is_not_collator() {

1369

1

	ExtBuilder::default()

1370

1

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

1371

1

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

1372

1

		.build()

1373

1

		.execute_with(|| {

1374

1

			// Enable killswitch

1375

1

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

1376

1

1377

1

			set_block_author(1);

1378

1

1379

1

			roll_to_round_begin(2);

1380

1

			assert_events_eq!(

1381

1

				Event::CollatorChosen {

1382

1

					round: 2,

1383

1

					collator_account: 1,

1384

1

					total_exposed_amount: 80,

1385

1

},

1386

1

				Event::CollatorChosen {

1387

1

					round: 2,

1388

1

					collator_account: 2,

1389

1

					total_exposed_amount: 80,

1390

1

},

1391

1

				Event::CollatorChosen {

1392

1

					round: 2,

1393

1

					collator_account: 3,

1394

1

					total_exposed_amount: 80,

1395

1

},

1396

1

				Event::CollatorChosen {

1397

1

					round: 2,

1398

1

					collator_account: 4,

1399

1

					total_exposed_amount: 80,

1400

1

},

1401

1

				Event::CollatorChosen {

1402

1

					round: 2,

1403

1

					collator_account: 5,

1404

1

					total_exposed_amount: 80,

1405

1

},

1406

1

				Event::NewRound {

1407

1

					starting_block: 5,

1408

1

					round: 2,

1409

1

					selected_collators_number: 5,

1410

1

					total_balance: 400,

1411

1

},

1412

1

);

1413

1

			roll_blocks(1);

1414

1

1415

1

			assert_ok!(ParachainStaking::join_candidates(

1416

1

				RuntimeOrigin::signed(6),

1417

1

10,

1418

1

1419

1

));

1420

1421

			// Round 6

1422

1

			roll_to_round_begin(6);

1423

1

			assert_events_eq!(

1424

1

				Event::CollatorChosen {

1425

1

					round: 6,

1426

1

					collator_account: 1,

1427

1

					total_exposed_amount: 80,

1428

1

},

1429

1

				Event::CollatorChosen {

1430

1

					round: 6,

1431

1

					collator_account: 2,

1432

1

					total_exposed_amount: 80,

1433

1

},

1434

1

				Event::CollatorChosen {

1435

1

					round: 6,

1436

1

					collator_account: 3,

1437

1

					total_exposed_amount: 80,

1438

1

},

1439

1

				Event::CollatorChosen {

1440

1

					round: 6,

1441

1

					collator_account: 4,

1442

1

					total_exposed_amount: 80,

1443

1

},

1444

1

				Event::CollatorChosen {

1445

1

					round: 6,

1446

1

					collator_account: 5,

1447

1

					total_exposed_amount: 80,

1448

1

},

1449

1

				Event::NewRound {

1450

1

					starting_block: 25,

1451

1

					round: 6,

1452

1

					selected_collators_number: 5,

1453

1

					total_balance: 400,

1454

1

},

1455

1

);

1456

1

			roll_blocks(1);

1457

1

1458

1

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

1459

1

			// to produce blocks

1460

1

			assert_noop!(

1461

1

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

1462

1

				Error::<Test>::CannotBeNotifiedAsInactive

1463

1

);

1464

1

});

1465

1

1466

1467

#[test]

1468

1

fn notify_inactive_collator_fails_cannot_be_notified_as_inactive() {

1469

1

	ExtBuilder::default()

1470

1

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

1471

1

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

1472

1

		.build()

1473

1

		.execute_with(|| {

1474

1

			// Enable killswitch

1475

1

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

1476

1

1477

1

			// Round 2

1478

1

			roll_to_round_begin(2);

1479

1

1480

1

			// Change block author

1481

1

			set_block_author(1);

1482

1

1483

1

			// Round 3

1484

1

			roll_to_round_begin(3);

1485

1

			roll_blocks(1);

1486

1

1487

1

			// Round 4

1488

1

			roll_to_round_begin(4);

1489

1

			roll_blocks(1);

1490

1

1491

1

			// Call 'notify_inactive_collator' extrinsic

1492

1

			assert_noop!(

1493

1

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

1494

1

				Error::<Test>::CannotBeNotifiedAsInactive

1495

1

);

1496

1

});

1497

1

1498

1499

#[test]

1500

1

fn notify_inactive_collator_fails_round_too_low() {

1501

1

	ExtBuilder::default()

1502

1

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

1503

1

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

1504

1

		.build()

1505

1

		.execute_with(|| {

1506

1

			// Enable killswitch

1507

1

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

1508

1

1509

1

			// Round 1

1510

1

			roll_to_round_begin(1);

1511

1

			roll_blocks(1);

1512

1

1513

1

			// Call 'notify_inactive_collator' extrinsic

1514

1

			assert_noop!(

1515

1

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

1516

1

				Error::<Test>::CurrentRoundTooLow

1517

1

);

1518

1

});

1519

1

1520

1521

#[test]

1522

1

fn sufficient_leave_candidates_weight_hint_succeeds() {

1523

1

	ExtBuilder::default()

1524

1

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

1525

1

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

1526

1

		.build()

1527

1

		.execute_with(|| {

1528

1

			let mut count = 5u32;

1529

6

			for i in 1..6 {

1530

5

				assert_ok!(ParachainStaking::schedule_leave_candidates(

1531

5

					RuntimeOrigin::signed(i),

1532

5

					count

1533

5

));

1534

5

				count -= 1u32;

1535

1536

1

});

1537

1

1538

1539

// EXECUTE LEAVE CANDIDATES

1540

1541

#[test]

1542

1

fn execute_leave_candidates_emits_event() {

1543

1

	ExtBuilder::default()

1544

1

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

1545

1

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

1546

1

		.build()

1547

1

		.execute_with(|| {

1548

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1549

1

				RuntimeOrigin::signed(1),

1550

1

				1u32

1551

1

));

1552

1

			roll_to(10);

1553

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1554

1

				RuntimeOrigin::signed(1),

1555

1

1,

1556

1

1557

1

));

1558

1

			assert_events_emitted!(Event::CandidateLeft {

1559

1

				ex_candidate: 1,

1560

1

				unlocked_amount: 10,

1561

1

				new_total_amt_locked: 0

1562

1

});

1563

1

});

1564

1

1565

1566

#[test]

1567

1

fn execute_leave_candidates_callable_by_any_signed() {

1568

1

	ExtBuilder::default()

1569

1

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

1570

1

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

1571

1

		.build()

1572

1

		.execute_with(|| {

1573

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1574

1

				RuntimeOrigin::signed(1),

1575

1

				1u32

1576

1

));

1577

1

			roll_to(10);

1578

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1579

1

				RuntimeOrigin::signed(2),

1580

1

1,

1581

1

1582

1

));

1583

1

});

1584

1

1585

1586

#[test]

1587

1

fn execute_leave_candidates_requires_correct_weight_hint() {

1588

1

	ExtBuilder::default()

1589

1

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

1590

1

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

1591

1

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

1592

1

		.build()

1593

1

		.execute_with(|| {

1594

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1595

1

				RuntimeOrigin::signed(1),

1596

1

				1u32

1597

1

));

1598

1

			roll_to(10);

1599

4

			for i in 0..3 {

1600

3

				assert_noop!(

1601

3

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

1602

3

					Error::<Test>::TooLowCandidateDelegationCountToLeaveCandidates

1603

3

);

1604

1605

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1606

1

				RuntimeOrigin::signed(2),

1607

1

1,

1608

1

1609

1

));

1610

1

});

1611

1

1612

1613

#[test]

1614

1

fn execute_leave_candidates_unreserves_balance() {

1615

1

	ExtBuilder::default()

1616

1

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

1617

1

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

1618

1

		.build()

1619

1

		.execute_with(|| {

1620

1

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

1621

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1622

1

				RuntimeOrigin::signed(1),

1623

1

				1u32

1624

1

));

1625

1

			roll_to(10);

1626

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1627

1

				RuntimeOrigin::signed(1),

1628

1

1,

1629

1

1630

1

));

1631

1

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

1632

1

});

1633

1

1634

1635

#[test]

1636

1

fn execute_leave_candidates_decreases_total_staked() {

1637

1

	ExtBuilder::default()

1638

1

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

1639

1

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

1640

1

		.build()

1641

1

		.execute_with(|| {

1642

1

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

1643

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1644

1

				RuntimeOrigin::signed(1),

1645

1

				1u32

1646

1

));

1647

1

			roll_to(10);

1648

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1649

1

				RuntimeOrigin::signed(1),

1650

1

1,

1651

1

1652

1

));

1653

1

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

1654

1

});

1655

1

1656

1657

#[test]

1658

1

fn execute_leave_candidates_removes_candidate_state() {

1659

1

	ExtBuilder::default()

1660

1

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

1661

1

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

1662

1

		.build()

1663

1

		.execute_with(|| {

1664

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1665

1

				RuntimeOrigin::signed(1),

1666

1

				1u32

1667

1

));

1668

			// candidate state is not immediately removed

1669

1

			let candidate_state =

1670

1

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

1671

1

			assert_eq!(candidate_state.bond, 10u128);

1672

1

			roll_to(10);

1673

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1674

1

				RuntimeOrigin::signed(1),

1675

1

1,

1676

1

1677

1

));

1678

1

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

1679

1

});

1680

1

1681

1682

#[test]

1683

1

fn execute_leave_candidates_removes_pending_delegation_requests() {

1684

1

	ExtBuilder::default()

1685

1

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

1686

1

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

1687

1

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

1688

1

		.build()

1689

1

		.execute_with(|| {

1690

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

1691

1

				RuntimeOrigin::signed(2),

1692

1

1,

1693

1

1694

1

));

1695

1

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

1696

1

			assert_eq!(

1697

1

				state,

1698

1

				vec![ScheduledRequest {

1699

1

					delegator: 2,

1700

1

					when_executable: 3,

1701

1

					action: DelegationAction::Decrease(5),

1702

1

}],

1703

1

);

1704

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1705

1

				RuntimeOrigin::signed(1),

1706

1

				1u32

1707

1

));

1708

			// candidate state is not immediately removed

1709

1

			let candidate_state =

1710

1

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

1711

1

			assert_eq!(candidate_state.bond, 10u128);

1712

1

			roll_to(10);

1713

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1714

1

				RuntimeOrigin::signed(1),

1715

1

1,

1716

1

1717

1

));

1718

1

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

1719

1

			assert!(

1720

1

				!ParachainStaking::delegation_scheduled_requests(&1)

1721

1

					.iter()

1722

1

					.any(|x| x.delegator == 2),

1723

				"delegation request not removed"

1724

);

1725

1

			assert!(

1726

1

				!<DelegationScheduledRequests<Test>>::contains_key(&1),

1727

				"the key was not removed from storage"

1728

);

1729

1

});

1730

1

1731

1732

#[test]

1733

1

fn cannot_execute_leave_candidates_before_delay() {

1734

1

	ExtBuilder::default()

1735

1

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

1736

1

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

1737

1

		.build()

1738

1

		.execute_with(|| {

1739

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1740

1

				RuntimeOrigin::signed(1),

1741

1

				1u32

1742

1

));

1743

1

			assert_noop!(

1744

1

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

1745

1

					.map_err(|err| err.error),

1746

1

				Error::<Test>::CandidateCannotLeaveYet

1747

1

);

1748

1

			roll_to(9);

1749

1

			assert_noop!(

1750

1

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

1751

1

					.map_err(|err| err.error),

1752

1

				Error::<Test>::CandidateCannotLeaveYet

1753

1

);

1754

1

			roll_to(10);

1755

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

1756

1

				RuntimeOrigin::signed(3),

1757

1

1,

1758

1

1759

1

));

1760

1

});

1761

1

1762

1763

// CANCEL LEAVE CANDIDATES

1764

1765

#[test]

1766

1

fn cancel_leave_candidates_emits_event() {

1767

1

	ExtBuilder::default()

1768

1

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

1769

1

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

1770

1

		.build()

1771

1

		.execute_with(|| {

1772

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1773

1

				RuntimeOrigin::signed(1),

1774

1

				1u32

1775

1

));

1776

1

			assert_ok!(ParachainStaking::cancel_leave_candidates(

1777

1

				RuntimeOrigin::signed(1),

1778

1

1779

1

));

1780

1

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

1781

1

});

1782

1

1783

1784

#[test]

1785

1

fn cancel_leave_candidates_updates_candidate_state() {

1786

1

	ExtBuilder::default()

1787

1

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

1788

1

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

1789

1

		.build()

1790

1

		.execute_with(|| {

1791

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1792

1

				RuntimeOrigin::signed(1),

1793

1

				1u32

1794

1

));

1795

1

			assert_ok!(ParachainStaking::cancel_leave_candidates(

1796

1

				RuntimeOrigin::signed(1),

1797

1

1798

1

));

1799

1

			let candidate =

1800

1

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

1801

1

			assert!(candidate.is_active());

1802

1

});

1803

1

1804

1805

#[test]

1806

1

fn cancel_leave_candidates_adds_to_candidate_pool() {

1807

1

	ExtBuilder::default()

1808

1

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

1809

1

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

1810

1

		.build()

1811

1

		.execute_with(|| {

1812

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1813

1

				RuntimeOrigin::signed(1),

1814

1

				1u32

1815

1

));

1816

1

			assert_ok!(ParachainStaking::cancel_leave_candidates(

1817

1

				RuntimeOrigin::signed(1),

1818

1

1819

1

));

1820

1

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

1821

1

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

1822

1

});

1823

1

1824

1825

// GO OFFLINE

1826

1827

#[test]

1828

1

fn go_offline_event_emits_correctly() {

1829

1

	ExtBuilder::default()

1830

1

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

1831

1

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

1832

1

		.build()

1833

1

		.execute_with(|| {

1834

1

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

1835

1

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

1836

1

});

1837

1

1838

1839

#[test]

1840

1

fn go_offline_removes_candidate_from_candidate_pool() {

1841

1

	ExtBuilder::default()

1842

1

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

1843

1

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

1844

1

		.build()

1845

1

		.execute_with(|| {

1846

1

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

1847

1

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

1848

1

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

1849

1

});

1850

1

1851

1852

#[test]

1853

1

fn go_offline_updates_candidate_state_to_idle() {

1854

1

	ExtBuilder::default()

1855

1

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

1856

1

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

1857

1

		.build()

1858

1

		.execute_with(|| {

1859

1

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

1860

1

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

1861

1

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

1862

1

			let candidate_state =

1863

1

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

1864

1

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

1865

1

});

1866

1

1867

1868

#[test]

1869

1

fn cannot_go_offline_if_not_candidate() {

1870

1

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

1871

1

		assert_noop!(

1872

1

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

1873

1

			Error::<Test>::CandidateDNE

1874

1

);

1875

1

});

1876

1

1877

1878

#[test]

1879

1

fn cannot_go_offline_if_already_offline() {

1880

1

	ExtBuilder::default()

1881

1

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

1882

1

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

1883

1

		.build()

1884

1

		.execute_with(|| {

1885

1

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

1886

1

			assert_noop!(

1887

1

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

1888

1

				Error::<Test>::AlreadyOffline

1889

1

);

1890

1

});

1891

1

1892

1893

// GO ONLINE

1894

1895

#[test]

1896

1

fn go_online_event_emits_correctly() {

1897

1

	ExtBuilder::default()

1898

1

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

1899

1

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

1900

1

		.build()

1901

1

		.execute_with(|| {

1902

1

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

1903

1

			roll_blocks(1);

1904

1

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

1905

1

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

1906

1

});

1907

1

1908

1909

#[test]

1910

1

fn go_online_adds_to_candidate_pool() {

1911

1

	ExtBuilder::default()

1912

1

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

1913

1

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

1914

1

		.build()

1915

1

		.execute_with(|| {

1916

1

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

1917

1

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

1918

1

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

1919

1

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

1920

1

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

1921

1

});

1922

1

1923

1924

#[test]

1925

1

fn go_online_storage_updates_candidate_state() {

1926

1

	ExtBuilder::default()

1927

1

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

1928

1

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

1929

1

		.build()

1930

1

		.execute_with(|| {

1931

1

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

1932

1

			let candidate_state =

1933

1

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

1934

1

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

1935

1

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

1936

1

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

1937

1

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

1938

1

});

1939

1

1940

1941

#[test]

1942

1

fn cannot_go_online_if_not_candidate() {

1943

1

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

1944

1

		assert_noop!(

1945

1

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

1946

1

			Error::<Test>::CandidateDNE

1947

1

);

1948

1

});

1949

1

1950

1951

#[test]

1952

1

fn cannot_go_online_if_already_online() {

1953

1

	ExtBuilder::default()

1954

1

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

1955

1

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

1956

1

		.build()

1957

1

		.execute_with(|| {

1958

1

			assert_noop!(

1959

1

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

1960

1

				Error::<Test>::AlreadyActive

1961

1

);

1962

1

});

1963

1

1964

1965

#[test]

1966

1

fn cannot_go_online_if_leaving() {

1967

1

	ExtBuilder::default()

1968

1

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

1969

1

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

1970

1

		.build()

1971

1

		.execute_with(|| {

1972

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

1973

1

				RuntimeOrigin::signed(1),

1974

1

1975

1

));

1976

1

			assert_noop!(

1977

1

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

1978

1

				Error::<Test>::CannotGoOnlineIfLeaving

1979

1

);

1980

1

});

1981

1

1982

1983

// CANDIDATE BOND MORE

1984

1985

#[test]

1986

1

fn candidate_bond_more_emits_correct_event() {

1987

1

	ExtBuilder::default()

1988

1

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

1989

1

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

1990

1

		.build()

1991

1

		.execute_with(|| {

1992

1

			assert_ok!(ParachainStaking::candidate_bond_more(

1993

1

				RuntimeOrigin::signed(1),

1994

1

1995

1

));

1996

1

			assert_events_eq!(Event::CandidateBondedMore {

1997

1

				candidate: 1,

1998

1

				amount: 30,

1999

1

				new_total_bond: 50

2000

1

});

2001

1

});

2002

1

2003

2004

#[test]

2005

1

fn candidate_bond_more_reserves_balance() {

2006

1

	ExtBuilder::default()

2007

1

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

2008

1

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

2009

1

		.build()

2010

1

		.execute_with(|| {

2011

1

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

2012

1

			assert_ok!(ParachainStaking::candidate_bond_more(

2013

1

				RuntimeOrigin::signed(1),

2014

1

2015

1

));

2016

1

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

2017

1

});

2018

1

2019

2020

#[test]

2021

1

fn candidate_bond_more_increases_total() {

2022

1

	ExtBuilder::default()

2023

1

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

2024

1

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

2025

1

		.build()

2026

1

		.execute_with(|| {

2027

1

			let mut total = ParachainStaking::total();

2028

1

			assert_ok!(ParachainStaking::candidate_bond_more(

2029

1

				RuntimeOrigin::signed(1),

2030

1

2031

1

));

2032

1

			total += 30;

2033

1

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

2034

1

});

2035

1

2036

2037

#[test]

2038

1

fn candidate_bond_more_updates_candidate_state() {

2039

1

	ExtBuilder::default()

2040

1

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

2041

1

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

2042

1

		.build()

2043

1

		.execute_with(|| {

2044

1

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

2045

1

			assert_eq!(candidate_state.bond, 20);

2046

1

			assert_ok!(ParachainStaking::candidate_bond_more(

2047

1

				RuntimeOrigin::signed(1),

2048

1

2049

1

));

2050

1

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

2051

1

			assert_eq!(candidate_state.bond, 50);

2052

1

});

2053

1

2054

2055

#[test]

2056

1

fn candidate_bond_more_updates_candidate_pool() {

2057

1

	ExtBuilder::default()

2058

1

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

2059

1

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

2060

1

		.build()

2061

1

		.execute_with(|| {

2062

1

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

2063

1

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

2064

1

			assert_ok!(ParachainStaking::candidate_bond_more(

2065

1

				RuntimeOrigin::signed(1),

2066

1

2067

1

));

2068

1

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

2069

1

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

2070

1

});

2071

1

2072

2073

// SCHEDULE CANDIDATE BOND LESS

2074

2075

#[test]

2076

1

fn schedule_candidate_bond_less_event_emits_correctly() {

2077

1

	ExtBuilder::default()

2078

1

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

2079

1

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

2080

1

		.build()

2081

1

		.execute_with(|| {

2082

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2083

1

				RuntimeOrigin::signed(1),

2084

1

2085

1

));

2086

1

			assert_events_eq!(Event::CandidateBondLessRequested {

2087

1

				candidate: 1,

2088

1

				amount_to_decrease: 10,

2089

1

				execute_round: 3,

2090

1

});

2091

1

});

2092

1

2093

2094

#[test]

2095

1

fn cannot_schedule_candidate_bond_less_if_request_exists() {

2096

1

	ExtBuilder::default()

2097

1

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

2098

1

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

2099

1

		.build()

2100

1

		.execute_with(|| {

2101

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2102

1

				RuntimeOrigin::signed(1),

2103

1

2104

1

));

2105

1

			assert_noop!(

2106

1

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

2107

1

				Error::<Test>::PendingCandidateRequestAlreadyExists

2108

1

);

2109

1

});

2110

1

2111

2112

#[test]

2113

1

fn cannot_schedule_candidate_bond_less_if_not_candidate() {

2114

1

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

2115

1

		assert_noop!(

2116

1

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

2117

1

			Error::<Test>::CandidateDNE

2118

1

);

2119

1

});

2120

1

2121

2122

#[test]

2123

1

fn cannot_schedule_candidate_bond_less_if_new_total_below_min_candidate_stk() {

2124

1

	ExtBuilder::default()

2125

1

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

2126

1

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

2127

1

		.build()

2128

1

		.execute_with(|| {

2129

1

			assert_noop!(

2130

1

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

2131

1

				Error::<Test>::CandidateBondBelowMin

2132

1

);

2133

1

});

2134

1

2135

2136

#[test]

2137

1

fn can_schedule_candidate_bond_less_if_leaving_candidates() {

2138

1

	ExtBuilder::default()

2139

1

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

2140

1

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

2141

1

		.build()

2142

1

		.execute_with(|| {

2143

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

2144

1

				RuntimeOrigin::signed(1),

2145

1

2146

1

));

2147

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2148

1

				RuntimeOrigin::signed(1),

2149

1

2150

1

));

2151

1

});

2152

1

2153

2154

#[test]

2155

1

fn cannot_schedule_candidate_bond_less_if_exited_candidates() {

2156

1

	ExtBuilder::default()

2157

1

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

2158

1

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

2159

1

		.build()

2160

1

		.execute_with(|| {

2161

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

2162

1

				RuntimeOrigin::signed(1),

2163

1

2164

1

));

2165

1

			roll_to(10);

2166

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

2167

1

				RuntimeOrigin::signed(1),

2168

1

1,

2169

1

2170

1

));

2171

1

			assert_noop!(

2172

1

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

2173

1

				Error::<Test>::CandidateDNE

2174

1

);

2175

1

});

2176

1

2177

2178

// 2. EXECUTE BOND LESS REQUEST

2179

2180

#[test]

2181

1

fn execute_candidate_bond_less_emits_correct_event() {

2182

1

	ExtBuilder::default()

2183

1

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

2184

1

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

2185

1

		.build()

2186

1

		.execute_with(|| {

2187

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2188

1

				RuntimeOrigin::signed(1),

2189

1

2190

1

));

2191

1

			roll_to(10);

2192

1

			roll_blocks(1);

2193

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2194

1

				RuntimeOrigin::signed(1),

2195

1

2196

1

));

2197

1

			assert_events_eq!(Event::CandidateBondedLess {

2198

1

				candidate: 1,

2199

1

				amount: 30,

2200

1

				new_bond: 20

2201

1

});

2202

1

});

2203

1

2204

2205

#[test]

2206

1

fn execute_candidate_bond_less_unreserves_balance() {

2207

1

	ExtBuilder::default()

2208

1

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

2209

1

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

2210

1

		.build()

2211

1

		.execute_with(|| {

2212

1

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

2213

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2214

1

				RuntimeOrigin::signed(1),

2215

1

2216

1

));

2217

1

			roll_to(10);

2218

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2219

1

				RuntimeOrigin::signed(1),

2220

1

2221

1

));

2222

1

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

2223

1

});

2224

1

2225

2226

#[test]

2227

1

fn execute_candidate_bond_less_decreases_total() {

2228

1

	ExtBuilder::default()

2229

1

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

2230

1

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

2231

1

		.build()

2232

1

		.execute_with(|| {

2233

1

			let mut total = ParachainStaking::total();

2234

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2235

1

				RuntimeOrigin::signed(1),

2236

1

2237

1

));

2238

1

			roll_to(10);

2239

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2240

1

				RuntimeOrigin::signed(1),

2241

1

2242

1

));

2243

1

			total -= 10;

2244

1

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

2245

1

});

2246

1

2247

2248

#[test]

2249

1

fn execute_candidate_bond_less_updates_candidate_state() {

2250

1

	ExtBuilder::default()

2251

1

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

2252

1

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

2253

1

		.build()

2254

1

		.execute_with(|| {

2255

1

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

2256

1

			assert_eq!(candidate_state.bond, 30);

2257

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2258

1

				RuntimeOrigin::signed(1),

2259

1

2260

1

));

2261

1

			roll_to(10);

2262

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2263

1

				RuntimeOrigin::signed(1),

2264

1

2265

1

));

2266

1

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

2267

1

			assert_eq!(candidate_state.bond, 20);

2268

1

});

2269

1

2270

2271

#[test]

2272

1

fn execute_candidate_bond_less_updates_candidate_pool() {

2273

1

	ExtBuilder::default()

2274

1

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

2275

1

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

2276

1

		.build()

2277

1

		.execute_with(|| {

2278

1

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

2279

1

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

2280

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2281

1

				RuntimeOrigin::signed(1),

2282

1

2283

1

));

2284

1

			roll_to(10);

2285

1

			assert_ok!(ParachainStaking::execute_candidate_bond_less(

2286

1

				RuntimeOrigin::signed(1),

2287

1

2288

1

));

2289

1

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

2290

1

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

2291

1

});

2292

1

2293

2294

// CANCEL CANDIDATE BOND LESS REQUEST

2295

2296

#[test]

2297

1

fn cancel_candidate_bond_less_emits_event() {

2298

1

	ExtBuilder::default()

2299

1

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

2300

1

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

2301

1

		.build()

2302

1

		.execute_with(|| {

2303

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2304

1

				RuntimeOrigin::signed(1),

2305

1

2306

1

));

2307

1

			assert_ok!(ParachainStaking::cancel_candidate_bond_less(

2308

1

				RuntimeOrigin::signed(1)

2309

1

));

2310

1

			assert_events_emitted!(Event::CancelledCandidateBondLess {

2311

1

				candidate: 1,

2312

1

				amount: 10,

2313

1

				execute_round: 3,

2314

1

});

2315

1

});

2316

1

2317

2318

#[test]

2319

1

fn cancel_candidate_bond_less_updates_candidate_state() {

2320

1

	ExtBuilder::default()

2321

1

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

2322

1

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

2323

1

		.build()

2324

1

		.execute_with(|| {

2325

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2326

1

				RuntimeOrigin::signed(1),

2327

1

2328

1

));

2329

1

			assert_ok!(ParachainStaking::cancel_candidate_bond_less(

2330

1

				RuntimeOrigin::signed(1)

2331

1

));

2332

1

			assert!(ParachainStaking::candidate_info(&1)

2333

1

				.unwrap()

2334

1

				.request

2335

1

				.is_none());

2336

1

});

2337

1

2338

2339

#[test]

2340

1

fn only_candidate_can_cancel_candidate_bond_less_request() {

2341

1

	ExtBuilder::default()

2342

1

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

2343

1

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

2344

1

		.build()

2345

1

		.execute_with(|| {

2346

1

			assert_ok!(ParachainStaking::schedule_candidate_bond_less(

2347

1

				RuntimeOrigin::signed(1),

2348

1

2349

1

));

2350

1

			assert_noop!(

2351

1

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

2352

1

				Error::<Test>::CandidateDNE

2353

1

);

2354

1

});

2355

1

2356

2357

// DELEGATE

2358

2359

#[test]

2360

1

fn delegate_event_emits_correctly() {

2361

1

	ExtBuilder::default()

2362

1

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

2363

1

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

2364

1

		.build()

2365

1

		.execute_with(|| {

2366

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2367

1

				RuntimeOrigin::signed(2),

2368

1

1,

2369

1

10,

2370

1

				Percent::zero(),

2371

1

0,

2372

1

0,

2373

1

2374

1

));

2375

1

			assert_events_eq!(Event::Delegation {

2376

1

				delegator: 2,

2377

1

				locked_amount: 10,

2378

1

				candidate: 1,

2379

1

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

2380

1

				auto_compound: Percent::zero(),

2381

1

});

2382

1

});

2383

1

2384

2385

#[test]

2386

1

fn delegate_reserves_balance() {

2387

1

	ExtBuilder::default()

2388

1

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

2389

1

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

2390

1

		.build()

2391

1

		.execute_with(|| {

2392

1

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

2393

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2394

1

				RuntimeOrigin::signed(2),

2395

1

1,

2396

1

10,

2397

1

				Percent::zero(),

2398

1

0,

2399

1

0,

2400

1

2401

1

));

2402

1

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

2403

1

});

2404

1

2405

2406

#[test]

2407

1

fn delegate_updates_delegator_state() {

2408

1

	ExtBuilder::default()

2409

1

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

2410

1

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

2411

1

		.build()

2412

1

		.execute_with(|| {

2413

1

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

2414

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2415

1

				RuntimeOrigin::signed(2),

2416

1

1,

2417

1

10,

2418

1

				Percent::zero(),

2419

1

0,

2420

1

0,

2421

1

2422

1

));

2423

1

			let delegator_state =

2424

1

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

2425

1

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

2426

1

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

2427

1

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

2428

1

});

2429

1

2430

2431

#[test]

2432

1

fn delegate_updates_collator_state() {

2433

1

	ExtBuilder::default()

2434

1

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

2435

1

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

2436

1

		.build()

2437

1

		.execute_with(|| {

2438

1

			let candidate_state =

2439

1

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

2440

1

			assert_eq!(candidate_state.total_counted, 30);

2441

1

			let top_delegations =

2442

1

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

2443

1

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

2444

1

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

2445

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2446

1

				RuntimeOrigin::signed(2),

2447

1

1,

2448

1

10,

2449

1

				Percent::zero(),

2450

1

0,

2451

1

0,

2452

1

2453

1

));

2454

1

			let candidate_state =

2455

1

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

2456

1

			assert_eq!(candidate_state.total_counted, 40);

2457

1

			let top_delegations =

2458

1

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

2459

1

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

2460

1

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

2461

1

			assert_eq!(top_delegations.total, 10);

2462

1

});

2463

1

2464

2465

#[test]

2466

1

fn can_delegate_immediately_after_other_join_candidates() {

2467

1

	ExtBuilder::default()

2468

1

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

2469

1

		.build()

2470

1

		.execute_with(|| {

2471

1

			assert_ok!(ParachainStaking::join_candidates(

2472

1

				RuntimeOrigin::signed(1),

2473

1

20,

2474

1

2475

1

));

2476

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2477

1

				RuntimeOrigin::signed(2),

2478

1

1,

2479

1

20,

2480

1

				Percent::zero(),

2481

1

0,

2482

1

0,

2483

1

2484

1

));

2485

1

});

2486

1

2487

2488

#[test]

2489

1

fn can_delegate_if_revoking() {

2490

1

	ExtBuilder::default()

2491

1

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

2492

1

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

2493

1

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

2494

1

		.build()

2495

1

		.execute_with(|| {

2496

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2497

1

				RuntimeOrigin::signed(2),

2498

1

2499

1

));

2500

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2501

1

				RuntimeOrigin::signed(2),

2502

1

4,

2503

1

10,

2504

1

				Percent::zero(),

2505

1

0,

2506

1

0,

2507

1

2508

1

));

2509

1

});

2510

1

2511

2512

#[test]

2513

1

fn cannot_delegate_if_full_and_new_delegation_less_than_or_equal_lowest_bottom() {

2514

1

	ExtBuilder::default()

2515

1

		.with_balances(vec![

2516

1

			(1, 20),

2517

1

			(2, 10),

2518

1

			(3, 10),

2519

1

			(4, 10),

2520

1

			(5, 10),

2521

1

			(6, 10),

2522

1

			(7, 10),

2523

1

			(8, 10),

2524

1

			(9, 10),

2525

1

			(10, 10),

2526

1

			(11, 10),

2527

1

])

2528

1

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

2529

1

		.with_delegations(vec![

2530

1

			(2, 1, 10),

2531

1

			(3, 1, 10),

2532

1

			(4, 1, 10),

2533

1

			(5, 1, 10),

2534

1

			(6, 1, 10),

2535

1

			(8, 1, 10),

2536

1

			(9, 1, 10),

2537

1

			(10, 1, 10),

2538

1

])

2539

1

		.build()

2540

1

		.execute_with(|| {

2541

1

			assert_noop!(

2542

1

				ParachainStaking::delegate_with_auto_compound(

2543

1

					RuntimeOrigin::signed(11),

2544

1

1,

2545

1

10,

2546

1

					Percent::zero(),

2547

1

8,

2548

1

0,

2549

1

2550

1

),

2551

1

				Error::<Test>::CannotDelegateLessThanOrEqualToLowestBottomWhenFull

2552

1

);

2553

1

});

2554

1

2555

2556

#[test]

2557

1

fn can_delegate_if_full_and_new_delegation_greater_than_lowest_bottom() {

2558

1

	ExtBuilder::default()

2559

1

		.with_balances(vec![

2560

1

			(1, 20),

2561

1

			(2, 10),

2562

1

			(3, 10),

2563

1

			(4, 10),

2564

1

			(5, 10),

2565

1

			(6, 10),

2566

1

			(7, 10),

2567

1

			(8, 10),

2568

1

			(9, 10),

2569

1

			(10, 10),

2570

1

			(11, 11),

2571

1

])

2572

1

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

2573

1

		.with_delegations(vec![

2574

1

			(2, 1, 10),

2575

1

			(3, 1, 10),

2576

1

			(4, 1, 10),

2577

1

			(5, 1, 10),

2578

1

			(6, 1, 10),

2579

1

			(8, 1, 10),

2580

1

			(9, 1, 10),

2581

1

			(10, 1, 10),

2582

1

])

2583

1

		.build()

2584

1

		.execute_with(|| {

2585

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2586

1

				RuntimeOrigin::signed(11),

2587

1

1,

2588

1

11,

2589

1

				Percent::zero(),

2590

1

8,

2591

1

0,

2592

1

2593

1

));

2594

1

			assert_events_emitted!(Event::DelegationKicked {

2595

1

				delegator: 10,

2596

1

				candidate: 1,

2597

1

				unstaked_amount: 10

2598

1

});

2599

1

			assert_events_emitted!(Event::DelegatorLeft {

2600

1

				delegator: 10,

2601

1

				unstaked_amount: 10

2602

1

});

2603

1

});

2604

1

2605

2606

#[test]

2607

1

fn can_still_delegate_if_leaving() {

2608

1

	ExtBuilder::default()

2609

1

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

2610

1

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

2611

1

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

2612

1

		.build()

2613

1

		.execute_with(|| {

2614

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2615

1

				RuntimeOrigin::signed(2),

2616

1

1,

2617

1

));

2618

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

2619

1

				RuntimeOrigin::signed(2),

2620

1

3,

2621

1

10,

2622

1

				Percent::zero(),

2623

1

0,

2624

1

0,

2625

1

2626

1

));

2627

1

});

2628

1

2629

2630

#[test]

2631

1

fn cannot_delegate_if_candidate() {

2632

1

	ExtBuilder::default()

2633

1

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

2634

1

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

2635

1

		.build()

2636

1

		.execute_with(|| {

2637

1

			assert_noop!(

2638

1

				ParachainStaking::delegate_with_auto_compound(

2639

1

					RuntimeOrigin::signed(2),

2640

1

1,

2641

1

10,

2642

1

					Percent::zero(),

2643

1

0,

2644

1

0,

2645

1

2646

1

),

2647

1

				Error::<Test>::CandidateExists

2648

1

);

2649

1

});

2650

1

2651

2652

#[test]

2653

1

fn cannot_delegate_if_already_delegated() {

2654

1

	ExtBuilder::default()

2655

1

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

2656

1

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

2657

1

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

2658

1

		.build()

2659

1

		.execute_with(|| {

2660

1

			assert_noop!(

2661

1

				ParachainStaking::delegate_with_auto_compound(

2662

1

					RuntimeOrigin::signed(2),

2663

1

1,

2664

1

10,

2665

1

					Percent::zero(),

2666

1

1,

2667

1

0,

2668

1

2669

1

),

2670

1

				Error::<Test>::AlreadyDelegatedCandidate

2671

1

);

2672

1

});

2673

1

2674

2675

#[test]

2676

1

fn cannot_delegate_more_than_max_delegations() {

2677

1

	ExtBuilder::default()

2678

1

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

2679

1

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

2680

1

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

2681

1

		.build()

2682

1

		.execute_with(|| {

2683

1

			assert_noop!(

2684

1

				ParachainStaking::delegate_with_auto_compound(

2685

1

					RuntimeOrigin::signed(2),

2686

1

6,

2687

1

10,

2688

1

					Percent::zero(),

2689

1

0,

2690

1

0,

2691

1

4,

2692

1

),

2693

1

				Error::<Test>::ExceedMaxDelegationsPerDelegator,

2694

1

);

2695

1

});

2696

1

2697

2698

#[test]

2699

1

fn sufficient_delegate_weight_hint_succeeds() {

2700

1

	ExtBuilder::default()

2701

1

		.with_balances(vec![

2702

1

			(1, 20),

2703

1

			(2, 20),

2704

1

			(3, 20),

2705

1

			(4, 20),

2706

1

			(5, 20),

2707

1

			(6, 20),

2708

1

			(7, 20),

2709

1

			(8, 20),

2710

1

			(9, 20),

2711

1

			(10, 20),

2712

1

])

2713

1

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

2714

1

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

2715

1

		.build()

2716

1

		.execute_with(|| {

2717

1

			let mut count = 4u32;

2718

5

			for i in 7..11 {

2719

4

				assert_ok!(ParachainStaking::delegate_with_auto_compound(

2720

4

					RuntimeOrigin::signed(i),

2721

4

1,

2722

4

10,

2723

4

					Percent::zero(),

2724

4

					count,

2725

4

0,

2726

4

2727

4

));

2728

4

				count += 1u32;

2729

2730

1

			let mut count = 0u32;

2731

9

			for i in 3..11 {

2732

8

				assert_ok!(ParachainStaking::delegate_with_auto_compound(

2733

8

					RuntimeOrigin::signed(i),

2734

8

2,

2735

8

10,

2736

8

					Percent::zero(),

2737

8

					count,

2738

8

0,

2739

8

					1u32

2740

8

));

2741

8

				count += 1u32;

2742

2743

1

});

2744

1

2745

2746

#[test]

2747

1

fn insufficient_delegate_weight_hint_fails() {

2748

1

	ExtBuilder::default()

2749

1

		.with_balances(vec![

2750

1

			(1, 20),

2751

1

			(2, 20),

2752

1

			(3, 20),

2753

1

			(4, 20),

2754

1

			(5, 20),

2755

1

			(6, 20),

2756

1

			(7, 20),

2757

1

			(8, 20),

2758

1

			(9, 20),

2759

1

			(10, 20),

2760

1

])

2761

1

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

2762

1

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

2763

1

		.build()

2764

1

		.execute_with(|| {

2765

1

			let mut count = 3u32;

2766

5

			for i in 7..11 {

2767

4

				assert_noop!(

2768

4

					ParachainStaking::delegate_with_auto_compound(

2769

4

						RuntimeOrigin::signed(i),

2770

4

1,

2771

4

10,

2772

4

						Percent::zero(),

2773

4

						count,

2774

4

0,

2775

4

2776

4

),

2777

4

					Error::<Test>::TooLowCandidateDelegationCountToDelegate

2778

4

);

2779

2780

			// to set up for next error test

2781

1

			count = 4u32;

2782

5

			for i in 7..11 {

2783

4

				assert_ok!(ParachainStaking::delegate_with_auto_compound(

2784

4

					RuntimeOrigin::signed(i),

2785

4

1,

2786

4

10,

2787

4

					Percent::zero(),

2788

4

					count,

2789

4

0,

2790

4

2791

4

));

2792

4

				count += 1u32;

2793

2794

1

			count = 0u32;

2795

9

			for i in 3..11 {

2796

8

				assert_noop!(

2797

8

					ParachainStaking::delegate_with_auto_compound(

2798

8

						RuntimeOrigin::signed(i),

2799

8

2,

2800

8

10,

2801

8

						Percent::zero(),

2802

8

						count,

2803

8

0,

2804

8

2805

8

),

2806

8

					Error::<Test>::TooLowDelegationCountToDelegate

2807

8

);

2808

8

				count += 1u32;

2809

2810

1

});

2811

1

2812

2813

// SCHEDULE REVOKE DELEGATION

2814

2815

#[test]

2816

1

fn revoke_delegation_event_emits_correctly() {

2817

1

	ExtBuilder::default()

2818

1

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

2819

1

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

2820

1

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

2821

1

		.build()

2822

1

		.execute_with(|| {

2823

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2824

1

				RuntimeOrigin::signed(2),

2825

1

2826

1

));

2827

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

2828

1

				round: 1,

2829

1

				delegator: 2,

2830

1

				candidate: 1,

2831

1

				scheduled_exit: 3,

2832

1

});

2833

1

			roll_to_round_begin(3);

2834

1

			roll_blocks(1);

2835

1

			assert_ok!(ParachainStaking::execute_delegation_request(

2836

1

				RuntimeOrigin::signed(2),

2837

1

2,

2838

1

2839

1

));

2840

1

			assert_events_eq!(

2841

1

				Event::DelegatorLeftCandidate {

2842

1

					delegator: 2,

2843

1

					candidate: 1,

2844

1

					unstaked_amount: 10,

2845

1

					total_candidate_staked: 30

2846

1

},

2847

1

				Event::DelegationRevoked {

2848

1

					delegator: 2,

2849

1

					candidate: 1,

2850

1

					unstaked_amount: 10,

2851

1

},

2852

1

);

2853

1

});

2854

1

2855

2856

#[test]

2857

1

fn can_revoke_delegation_if_revoking_another_delegation() {

2858

1

	ExtBuilder::default()

2859

1

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

2860

1

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

2861

1

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

2862

1

		.build()

2863

1

		.execute_with(|| {

2864

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2865

1

				RuntimeOrigin::signed(2),

2866

1

2867

1

));

2868

			// this is an exit implicitly because last delegation revoked

2869

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2870

1

				RuntimeOrigin::signed(2),

2871

1

2872

1

));

2873

1

});

2874

1

2875

2876

#[test]

2877

1

fn cannot_revoke_delegation_if_not_delegator() {

2878

1

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

2879

1

		assert_noop!(

2880

1

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

2881

1

			Error::<Test>::DelegatorDNE

2882

1

);

2883

1

});

2884

1

2885

2886

#[test]

2887

1

fn cannot_revoke_delegation_that_dne() {

2888

1

	ExtBuilder::default()

2889

1

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

2890

1

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

2891

1

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

2892

1

		.build()

2893

1

		.execute_with(|| {

2894

1

			assert_noop!(

2895

1

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

2896

1

				Error::<Test>::DelegationDNE

2897

1

);

2898

1

});

2899

1

2900

2901

#[test]

2902

1

fn can_schedule_revoke_delegation_below_min_delegator_stake() {

2903

1

	ExtBuilder::default()

2904

1

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

2905

1

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

2906

1

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

2907

1

		.build()

2908

1

		.execute_with(|| {

2909

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

2910

1

				RuntimeOrigin::signed(2),

2911

1

2912

1

));

2913

1

});

2914

1

2915

2916

// DELEGATOR BOND MORE

2917

2918

#[test]

2919

1

fn delegator_bond_more_reserves_balance() {

2920

1

	ExtBuilder::default()

2921

1

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

2922

1

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

2923

1

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

2924

1

		.build()

2925

1

		.execute_with(|| {

2926

1

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

2927

1

			assert_ok!(ParachainStaking::delegator_bond_more(

2928

1

				RuntimeOrigin::signed(2),

2929

1

1,

2930

1

2931

1

));

2932

1

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

2933

1

});

2934

1

2935

2936

#[test]

2937

1

fn delegator_bond_more_increases_total_staked() {

2938

1

	ExtBuilder::default()

2939

1

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

2940

1

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

2941

1

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

2942

1

		.build()

2943

1

		.execute_with(|| {

2944

1

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

2945

1

			assert_ok!(ParachainStaking::delegator_bond_more(

2946

1

				RuntimeOrigin::signed(2),

2947

1

1,

2948

1

2949

1

));

2950

1

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

2951

1

});

2952

1

2953

2954

#[test]

2955

1

fn delegator_bond_more_updates_delegator_state() {

2956

1

	ExtBuilder::default()

2957

1

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

2958

1

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

2959

1

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

2960

1

		.build()

2961

1

		.execute_with(|| {

2962

1

			assert_eq!(

2963

1

				ParachainStaking::delegator_state(2)

2964

1

					.expect("exists")

2965

1

					.total(),

2966

1

2967

1

);

2968

1

			assert_ok!(ParachainStaking::delegator_bond_more(

2969

1

				RuntimeOrigin::signed(2),

2970

1

1,

2971

1

2972

1

));

2973

1

			assert_eq!(

2974

1

				ParachainStaking::delegator_state(2)

2975

1

					.expect("exists")

2976

1

					.total(),

2977

1

2978

1

);

2979

1

});

2980

1

2981

2982

#[test]

2983

1

fn delegator_bond_more_updates_candidate_state_top_delegations() {

2984

1

	ExtBuilder::default()

2985

1

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

2986

1

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

2987

1

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

2988

1

		.build()

2989

1

		.execute_with(|| {

2990

1

			assert_eq!(

2991

1

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

2992

1

2993

1

);

2994

1

			assert_eq!(

2995

1

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

2996

1

2997

1

);

2998

1

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

2999

1

			assert_ok!(ParachainStaking::delegator_bond_more(

3000

1

				RuntimeOrigin::signed(2),

3001

1

1,

3002

1

3003

1

));

3004

1

			assert_eq!(

3005

1

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

3006

1

3007

1

);

3008

1

			assert_eq!(

3009

1

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

3010

1

3011

1

);

3012

1

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

3013

1

});

3014

1

3015

3016

#[test]

3017

1

fn delegator_bond_more_updates_candidate_state_bottom_delegations() {

3018

1

	ExtBuilder::default()

3019

1

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

3020

1

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

3021

1

		.with_delegations(vec![

3022

1

			(2, 1, 10),

3023

1

			(3, 1, 20),

3024

1

			(4, 1, 20),

3025

1

			(5, 1, 20),

3026

1

			(6, 1, 20),

3027

1

])

3028

1

		.build()

3029

1

		.execute_with(|| {

3030

1

			assert_eq!(

3031

1

				ParachainStaking::bottom_delegations(1)

3032

1

					.expect("exists")

3033

1

					.delegations[0]

3034

1

					.owner,

3035

1

3036

1

);

3037

1

			assert_eq!(

3038

1

				ParachainStaking::bottom_delegations(1)

3039

1

					.expect("exists")

3040

1

					.delegations[0]

3041

1

					.amount,

3042

1

3043

1

);

3044

1

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

3045

1

			assert_ok!(ParachainStaking::delegator_bond_more(

3046

1

				RuntimeOrigin::signed(2),

3047

1

1,

3048

1

3049

1

));

3050

1

			assert_events_eq!(Event::DelegationIncreased {

3051

1

				delegator: 2,

3052

1

				candidate: 1,

3053

1

				amount: 5,

3054

1

				in_top: false

3055

1

});

3056

1

			assert_eq!(

3057

1

				ParachainStaking::bottom_delegations(1)

3058

1

					.expect("exists")

3059

1

					.delegations[0]

3060

1

					.owner,

3061

1

3062

1

);

3063

1

			assert_eq!(

3064

1

				ParachainStaking::bottom_delegations(1)

3065

1

					.expect("exists")

3066

1

					.delegations[0]

3067

1

					.amount,

3068

1

3069

1

);

3070

1

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

3071

1

});

3072

1

3073

3074

#[test]

3075

1

fn delegator_bond_more_increases_total() {

3076

1

	ExtBuilder::default()

3077

1

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

3078

1

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

3079

1

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

3080

1

		.build()

3081

1

		.execute_with(|| {

3082

1

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

3083

1

			assert_ok!(ParachainStaking::delegator_bond_more(

3084

1

				RuntimeOrigin::signed(2),

3085

1

1,

3086

1

3087

1

));

3088

1

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

3089

1

});

3090

1

3091

3092

#[test]

3093

1

fn can_delegator_bond_more_for_leaving_candidate() {

3094

1

	ExtBuilder::default()

3095

1

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

3096

1

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

3097

1

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

3098

1

		.build()

3099

1

		.execute_with(|| {

3100

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

3101

1

				RuntimeOrigin::signed(1),

3102

1

3103

1

));

3104

1

			assert_ok!(ParachainStaking::delegator_bond_more(

3105

1

				RuntimeOrigin::signed(2),

3106

1

1,

3107

1

3108

1

));

3109

1

});

3110

1

3111

3112

#[test]

3113

1

fn delegator_bond_more_disallowed_when_revoke_scheduled() {

3114

1

	ExtBuilder::default()

3115

1

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

3116

1

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

3117

1

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

3118

1

		.build()

3119

1

		.execute_with(|| {

3120

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3121

1

				RuntimeOrigin::signed(2),

3122

1

3123

1

));

3124

1

			assert_noop!(

3125

1

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

3126

1

				<Error<Test>>::PendingDelegationRevoke

3127

1

);

3128

1

});

3129

1

3130

3131

#[test]

3132

1

fn delegator_bond_more_allowed_when_bond_decrease_scheduled() {

3133

1

	ExtBuilder::default()

3134

1

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

3135

1

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

3136

1

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

3137

1

		.build()

3138

1

		.execute_with(|| {

3139

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3140

1

				RuntimeOrigin::signed(2),

3141

1

1,

3142

1

5,

3143

1

));

3144

1

			assert_ok!(ParachainStaking::delegator_bond_more(

3145

1

				RuntimeOrigin::signed(2),

3146

1

1,

3147

1

3148

1

));

3149

1

});

3150

1

3151

3152

// DELEGATOR BOND LESS

3153

3154

#[test]

3155

1

fn delegator_bond_less_event_emits_correctly() {

3156

1

	ExtBuilder::default()

3157

1

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

3158

1

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

3159

1

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

3160

1

		.build()

3161

1

		.execute_with(|| {

3162

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3163

1

				RuntimeOrigin::signed(2),

3164

1

1,

3165

1

3166

1

));

3167

1

			assert_events_eq!(Event::DelegationDecreaseScheduled {

3168

1

				delegator: 2,

3169

1

				candidate: 1,

3170

1

				amount_to_decrease: 5,

3171

1

				execute_round: 3,

3172

1

});

3173

1

});

3174

1

3175

3176

#[test]

3177

1

fn delegator_bond_less_updates_delegator_state() {

3178

1

	ExtBuilder::default()

3179

1

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

3180

1

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

3181

1

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

3182

1

		.build()

3183

1

		.execute_with(|| {

3184

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3185

1

				RuntimeOrigin::signed(2),

3186

1

1,

3187

1

3188

1

));

3189

1

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

3190

1

			assert_eq!(

3191

1

				state,

3192

1

				vec![ScheduledRequest {

3193

1

					delegator: 2,

3194

1

					when_executable: 3,

3195

1

					action: DelegationAction::Decrease(5),

3196

1

}],

3197

1

);

3198

1

});

3199

1

3200

3201

#[test]

3202

1

fn cannot_delegator_bond_less_if_revoking() {

3203

1

	ExtBuilder::default()

3204

1

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

3205

1

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

3206

1

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

3207

1

		.build()

3208

1

		.execute_with(|| {

3209

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3210

1

				RuntimeOrigin::signed(2),

3211

1

3212

1

));

3213

1

			assert_noop!(

3214

1

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

3215

1

					.map_err(|err| err.error),

3216

1

				Error::<Test>::PendingDelegationRequestAlreadyExists

3217

1

);

3218

1

});

3219

1

3220

3221

#[test]

3222

1

fn cannot_delegator_bond_less_if_not_delegator() {

3223

1

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

3224

1

		assert_noop!(

3225

1

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

3226

1

				.map_err(|err| err.error),

3227

1

			Error::<Test>::DelegatorDNE

3228

1

);

3229

1

});

3230

1

3231

3232

#[test]

3233

1

fn cannot_delegator_bond_less_if_candidate_dne() {

3234

1

	ExtBuilder::default()

3235

1

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

3236

1

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

3237

1

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

3238

1

		.build()

3239

1

		.execute_with(|| {

3240

1

			assert_noop!(

3241

1

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

3242

1

					.map_err(|err| err.error),

3243

1

				Error::<Test>::DelegationDNE

3244

1

);

3245

1

});

3246

1

3247

3248

#[test]

3249

1

fn cannot_delegator_bond_less_if_delegation_dne() {

3250

1

	ExtBuilder::default()

3251

1

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

3252

1

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

3253

1

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

3254

1

		.build()

3255

1

		.execute_with(|| {

3256

1

			assert_noop!(

3257

1

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

3258

1

					.map_err(|err| err.error),

3259

1

				Error::<Test>::DelegationDNE

3260

1

);

3261

1

});

3262

1

3263

3264

#[test]

3265

1

fn cannot_delegator_bond_less_more_than_total_delegation() {

3266

1

	ExtBuilder::default()

3267

1

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

3268

1

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

3269

1

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

3270

1

		.build()

3271

1

		.execute_with(|| {

3272

1

			assert_noop!(

3273

1

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

3274

1

					.map_err(|err| err.error),

3275

1

				Error::<Test>::DelegatorBondBelowMin

3276

1

);

3277

1

});

3278

1

3279

3280

#[test]

3281

1

fn cannot_delegator_bond_less_below_min_delegation() {

3282

1

	ExtBuilder::default()

3283

1

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

3284

1

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

3285

1

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

3286

1

		.build()

3287

1

		.execute_with(|| {

3288

1

			assert_noop!(

3289

1

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

3290

1

					.map_err(|err| err.error),

3291

1

				Error::<Test>::DelegationBelowMin

3292

1

);

3293

1

});

3294

1

3295

3296

// EXECUTE PENDING DELEGATION REQUEST

3297

3298

// 1. REVOKE DELEGATION

3299

3300

#[test]

3301

1

fn execute_revoke_delegation_emits_exit_event_if_exit_happens() {

3302

1

	// last delegation is revocation

3303

1

	ExtBuilder::default()

3304

1

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

3305

1

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

3306

1

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

3307

1

		.build()

3308

1

		.execute_with(|| {

3309

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3310

1

				RuntimeOrigin::signed(2),

3311

1

3312

1

));

3313

1

			roll_to(10);

3314

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3315

1

				RuntimeOrigin::signed(2),

3316

1

2,

3317

1

3318

1

));

3319

1

			assert_events_emitted!(Event::DelegatorLeftCandidate {

3320

1

				delegator: 2,

3321

1

				candidate: 1,

3322

1

				unstaked_amount: 10,

3323

1

				total_candidate_staked: 30

3324

1

});

3325

1

			assert_events_emitted!(Event::DelegatorLeft {

3326

1

				delegator: 2,

3327

1

				unstaked_amount: 10

3328

1

});

3329

1

});

3330

1

3331

3332

#[test]

3333

1

fn revoke_delegation_executes_exit_if_last_delegation() {

3334

1

	// last delegation is revocation

3335

1

	ExtBuilder::default()

3336

1

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

3337

1

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

3338

1

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

3339

1

		.build()

3340

1

		.execute_with(|| {

3341

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3342

1

				RuntimeOrigin::signed(2),

3343

1

3344

1

));

3345

1

			roll_to(10);

3346

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3347

1

				RuntimeOrigin::signed(2),

3348

1

2,

3349

1

3350

1

));

3351

1

			assert_events_emitted!(Event::DelegatorLeftCandidate {

3352

1

				delegator: 2,

3353

1

				candidate: 1,

3354

1

				unstaked_amount: 10,

3355

1

				total_candidate_staked: 30

3356

1

});

3357

1

			assert_events_emitted!(Event::DelegatorLeft {

3358

1

				delegator: 2,

3359

1

				unstaked_amount: 10

3360

1

});

3361

1

});

3362

1

3363

3364

#[test]

3365

1

fn execute_revoke_delegation_emits_correct_event() {

3366

1

	ExtBuilder::default()

3367

1

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

3368

1

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

3369

1

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

3370

1

		.build()

3371

1

		.execute_with(|| {

3372

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3373

1

				RuntimeOrigin::signed(2),

3374

1

3375

1

));

3376

1

			roll_to(10);

3377

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3378

1

				RuntimeOrigin::signed(2),

3379

1

2,

3380

1

3381

1

));

3382

1

			assert_events_emitted!(Event::DelegatorLeftCandidate {

3383

1

				delegator: 2,

3384

1

				candidate: 1,

3385

1

				unstaked_amount: 10,

3386

1

				total_candidate_staked: 30

3387

1

});

3388

1

});

3389

1

3390

3391

#[test]

3392

1

fn execute_revoke_delegation_unreserves_balance() {

3393

1

	ExtBuilder::default()

3394

1

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

3395

1

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

3396

1

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

3397

1

		.build()

3398

1

		.execute_with(|| {

3399

1

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

3400

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3401

1

				RuntimeOrigin::signed(2),

3402

1

3403

1

));

3404

1

			roll_to(10);

3405

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3406

1

				RuntimeOrigin::signed(2),

3407

1

2,

3408

1

3409

1

));

3410

1

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

3411

1

});

3412

1

3413

3414

#[test]

3415

1

fn execute_revoke_delegation_adds_revocation_to_delegator_state() {

3416

1

	ExtBuilder::default()

3417

1

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

3418

1

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

3419

1

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

3420

1

		.build()

3421

1

		.execute_with(|| {

3422

1

			assert!(!ParachainStaking::delegation_scheduled_requests(&1)

3423

1

				.iter()

3424

1

				.any(|x| x.delegator == 2));

3425

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3426

1

				RuntimeOrigin::signed(2),

3427

1

3428

1

));

3429

1

			assert!(ParachainStaking::delegation_scheduled_requests(&1)

3430

1

				.iter()

3431

1

				.any(|x| x.delegator == 2));

3432

1

});

3433

1

3434

3435

#[test]

3436

1

fn execute_revoke_delegation_removes_revocation_from_delegator_state_upon_execution() {

3437

1

	ExtBuilder::default()

3438

1

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

3439

1

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

3440

1

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

3441

1

		.build()

3442

1

		.execute_with(|| {

3443

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3444

1

				RuntimeOrigin::signed(2),

3445

1

3446

1

));

3447

1

			roll_to(10);

3448

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3449

1

				RuntimeOrigin::signed(2),

3450

1

2,

3451

1

3452

1

));

3453

1

			assert!(!ParachainStaking::delegation_scheduled_requests(&1)

3454

1

				.iter()

3455

1

				.any(|x| x.delegator == 2));

3456

1

});

3457

1

3458

3459

#[test]

3460

1

fn execute_revoke_delegation_removes_revocation_from_state_for_single_delegation_leave() {

3461

1

	ExtBuilder::default()

3462

1

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

3463

1

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

3464

1

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

3465

1

		.build()

3466

1

		.execute_with(|| {

3467

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3468

1

				RuntimeOrigin::signed(2),

3469

1

3470

1

));

3471

1

			roll_to(10);

3472

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3473

1

				RuntimeOrigin::signed(2),

3474

1

2,

3475

1

3476

1

));

3477

1

			assert!(

3478

1

				!ParachainStaking::delegation_scheduled_requests(&1)

3479

1

					.iter()

3480

1

					.any(|x| x.delegator == 2),

3481

				"delegation was not removed"

3482

);

3483

1

});

3484

1

3485

3486

#[test]

3487

1

fn execute_revoke_delegation_decreases_total_staked() {

3488

1

	ExtBuilder::default()

3489

1

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

3490

1

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

3491

1

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

3492

1

		.build()

3493

1

		.execute_with(|| {

3494

1

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

3495

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3496

1

				RuntimeOrigin::signed(2),

3497

1

3498

1

));

3499

1

			roll_to(10);

3500

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3501

1

				RuntimeOrigin::signed(2),

3502

1

2,

3503

1

3504

1

));

3505

1

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

3506

1

});

3507

1

3508

3509

#[test]

3510

1

fn execute_revoke_delegation_for_last_delegation_removes_delegator_state() {

3511

1

	ExtBuilder::default()

3512

1

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

3513

1

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

3514

1

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

3515

1

		.build()

3516

1

		.execute_with(|| {

3517

1

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

3518

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3519

1

				RuntimeOrigin::signed(2),

3520

1

3521

1

));

3522

1

			roll_to(10);

3523

1

			// this will be confusing for people

3524

1

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

3525

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3526

1

				RuntimeOrigin::signed(2),

3527

1

2,

3528

1

3529

1

));

3530

1

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

3531

1

});

3532

1

3533

3534

#[test]

3535

1

fn execute_revoke_delegation_removes_delegation_from_candidate_state() {

3536

1

	ExtBuilder::default()

3537

1

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

3538

1

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

3539

1

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

3540

1

		.build()

3541

1

		.execute_with(|| {

3542

1

			assert_eq!(

3543

1

				ParachainStaking::candidate_info(1)

3544

1

					.expect("exists")

3545

1

					.delegation_count,

3546

1

				1u32

3547

1

);

3548

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3549

1

				RuntimeOrigin::signed(2),

3550

1

3551

1

));

3552

1

			roll_to(10);

3553

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3554

1

				RuntimeOrigin::signed(2),

3555

1

2,

3556

1

3557

1

));

3558

1

			assert!(ParachainStaking::candidate_info(1)

3559

1

				.expect("exists")

3560

1

				.delegation_count

3561

1

				.is_zero());

3562

1

});

3563

1

3564

3565

#[test]

3566

1

fn can_execute_revoke_delegation_for_leaving_candidate() {

3567

1

	ExtBuilder::default()

3568

1

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

3569

1

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

3570

1

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

3571

1

		.build()

3572

1

		.execute_with(|| {

3573

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

3574

1

				RuntimeOrigin::signed(1),

3575

1

3576

1

));

3577

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3578

1

				RuntimeOrigin::signed(2),

3579

1

3580

1

));

3581

1

			roll_to(10);

3582

1

			// can execute delegation request for leaving candidate

3583

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3584

1

				RuntimeOrigin::signed(2),

3585

1

2,

3586

1

3587

1

));

3588

1

});

3589

1

3590

3591

#[test]

3592

1

fn can_execute_leave_candidates_if_revoking_candidate() {

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_ok!(ParachainStaking::schedule_leave_candidates(

3600

1

				RuntimeOrigin::signed(1),

3601

1

3602

1

));

3603

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3604

1

				RuntimeOrigin::signed(2),

3605

1

3606

1

));

3607

1

			roll_to(10);

3608

1

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

3609

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

3610

1

				RuntimeOrigin::signed(1),

3611

1

1,

3612

1

3613

1

));

3614

1

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

3615

1

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

3616

1

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

3617

1

});

3618

1

3619

3620

#[test]

3621

1

fn delegator_bond_more_after_revoke_delegation_does_not_effect_exit() {

3622

1

	ExtBuilder::default()

3623

1

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

3624

1

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

3625

1

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

3626

1

		.build()

3627

1

		.execute_with(|| {

3628

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3629

1

				RuntimeOrigin::signed(2),

3630

1

3631

1

));

3632

1

			assert_ok!(ParachainStaking::delegator_bond_more(

3633

1

				RuntimeOrigin::signed(2),

3634

1

3,

3635

1

3636

1

));

3637

1

			roll_to(100);

3638

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3639

1

				RuntimeOrigin::signed(2),

3640

1

2,

3641

1

3642

1

));

3643

1

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

3644

1

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

3645

1

});

3646

1

3647

3648

#[test]

3649

1

fn delegator_bond_less_after_revoke_delegation_does_not_effect_exit() {

3650

1

	ExtBuilder::default()

3651

1

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

3652

1

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

3653

1

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

3654

1

		.build()

3655

1

		.execute_with(|| {

3656

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

3657

1

				RuntimeOrigin::signed(2),

3658

1

3659

1

));

3660

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

3661

1

				round: 1,

3662

1

				delegator: 2,

3663

1

				candidate: 1,

3664

1

				scheduled_exit: 3,

3665

1

});

3666

1

			assert_noop!(

3667

1

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

3668

1

					.map_err(|err| err.error),

3669

1

				Error::<Test>::PendingDelegationRequestAlreadyExists

3670

1

);

3671

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3672

1

				RuntimeOrigin::signed(2),

3673

1

3,

3674

1

3675

1

));

3676

1

			roll_to(10);

3677

1

			roll_blocks(1);

3678

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3679

1

				RuntimeOrigin::signed(2),

3680

1

2,

3681

1

3682

1

));

3683

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3684

1

				RuntimeOrigin::signed(2),

3685

1

2,

3686

1

3687

1

));

3688

1

			assert_events_eq!(

3689

1

				Event::DelegatorLeftCandidate {

3690

1

					delegator: 2,

3691

1

					candidate: 1,

3692

1

					unstaked_amount: 10,

3693

1

					total_candidate_staked: 30,

3694

1

},

3695

1

				Event::DelegationRevoked {

3696

1

					delegator: 2,

3697

1

					candidate: 1,

3698

1

					unstaked_amount: 10,

3699

1

},

3700

1

				Event::DelegationDecreased {

3701

1

					delegator: 2,

3702

1

					candidate: 3,

3703

1

					amount: 2,

3704

1

					in_top: true

3705

1

},

3706

1

);

3707

1

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

3708

1

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

3709

1

});

3710

1

3711

3712

// 2. EXECUTE BOND LESS

3713

3714

#[test]

3715

1

fn execute_delegator_bond_less_unreserves_balance() {

3716

1

	ExtBuilder::default()

3717

1

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

3718

1

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

3719

1

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

3720

1

		.build()

3721

1

		.execute_with(|| {

3722

1

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

3723

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3724

1

				RuntimeOrigin::signed(2),

3725

1

1,

3726

1

3727

1

));

3728

1

			roll_to(10);

3729

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3730

1

				RuntimeOrigin::signed(2),

3731

1

2,

3732

1

3733

1

));

3734

1

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

3735

1

});

3736

1

3737

3738

#[test]

3739

1

fn execute_delegator_bond_less_decreases_total_staked() {

3740

1

	ExtBuilder::default()

3741

1

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

3742

1

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

3743

1

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

3744

1

		.build()

3745

1

		.execute_with(|| {

3746

1

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

3747

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3748

1

				RuntimeOrigin::signed(2),

3749

1

1,

3750

1

3751

1

));

3752

1

			roll_to(10);

3753

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3754

1

				RuntimeOrigin::signed(2),

3755

1

2,

3756

1

3757

1

));

3758

1

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

3759

1

});

3760

1

3761

3762

#[test]

3763

1

fn execute_delegator_bond_less_updates_delegator_state() {

3764

1

	ExtBuilder::default()

3765

1

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

3766

1

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

3767

1

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

3768

1

		.build()

3769

1

		.execute_with(|| {

3770

1

			assert_eq!(

3771

1

				ParachainStaking::delegator_state(2)

3772

1

					.expect("exists")

3773

1

					.total(),

3774

1

3775

1

);

3776

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3777

1

				RuntimeOrigin::signed(2),

3778

1

1,

3779

1

3780

1

));

3781

1

			roll_to(10);

3782

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3783

1

				RuntimeOrigin::signed(2),

3784

1

2,

3785

1

3786

1

));

3787

1

			assert_eq!(

3788

1

				ParachainStaking::delegator_state(2)

3789

1

					.expect("exists")

3790

1

					.total(),

3791

1

3792

1

);

3793

1

});

3794

1

3795

3796

#[test]

3797

1

fn execute_delegator_bond_less_updates_candidate_state() {

3798

1

	ExtBuilder::default()

3799

1

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

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

3805

1

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

3806

1

3807

1

);

3808

1

			assert_eq!(

3809

1

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

3810

1

3811

1

);

3812

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3813

1

				RuntimeOrigin::signed(2),

3814

1

1,

3815

1

3816

1

));

3817

1

			roll_to(10);

3818

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3819

1

				RuntimeOrigin::signed(2),

3820

1

2,

3821

1

3822

1

));

3823

1

			assert_eq!(

3824

1

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

3825

1

3826

1

);

3827

1

			assert_eq!(

3828

1

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

3829

1

3830

1

);

3831

1

});

3832

1

3833

3834

#[test]

3835

1

fn execute_delegator_bond_less_decreases_total() {

3836

1

	ExtBuilder::default()

3837

1

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

3838

1

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

3839

1

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

3840

1

		.build()

3841

1

		.execute_with(|| {

3842

1

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

3843

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3844

1

				RuntimeOrigin::signed(2),

3845

1

1,

3846

1

3847

1

));

3848

1

			roll_to(10);

3849

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3850

1

				RuntimeOrigin::signed(2),

3851

1

2,

3852

1

3853

1

));

3854

1

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

3855

1

});

3856

1

3857

3858

#[test]

3859

1

fn execute_delegator_bond_less_updates_just_bottom_delegations() {

3860

1

	ExtBuilder::default()

3861

1

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

3862

1

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

3863

1

		.with_delegations(vec![

3864

1

			(2, 1, 10),

3865

1

			(3, 1, 11),

3866

1

			(4, 1, 12),

3867

1

			(5, 1, 14),

3868

1

			(6, 1, 15),

3869

1

])

3870

1

		.build()

3871

1

		.execute_with(|| {

3872

1

			let pre_call_candidate_info =

3873

1

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

3874

1

			let pre_call_top_delegations =

3875

1

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

3876

1

			let pre_call_bottom_delegations =

3877

1

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

3878

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3879

1

				RuntimeOrigin::signed(2),

3880

1

1,

3881

1

3882

1

));

3883

1

			roll_to(10);

3884

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3885

1

				RuntimeOrigin::signed(2),

3886

1

2,

3887

1

3888

1

));

3889

1

			let post_call_candidate_info =

3890

1

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

3891

1

			let post_call_top_delegations =

3892

1

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

3893

1

			let post_call_bottom_delegations =

3894

1

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

3895

1

			let mut not_equal = false;

3896

2

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

3897

				for Bond {

3898

1

					owner: post_owner,

3899

1

					amount: post_amount,

3900

1

				} in &post_call_bottom_delegations.delegations

3901

3902

1

					if &owner == post_owner {

3903

1

						if &amount != post_amount {

3904

1

							not_equal = true;

3905

1

							break;

3906

3907

3908

3909

3910

1

			assert!(not_equal);

3911

1

			let mut equal = true;

3912

5

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

3913

				for Bond {

3914

16

					owner: post_owner,

3915

16

					amount: post_amount,

3916

20

				} in &post_call_top_delegations.delegations

3917

3918

16

					if &owner == post_owner {

3919

4

						if &amount != post_amount {

3920

							equal = false;

3921

							break;

3922

4

3923

12

3924

3925

3926

1

			assert!(equal);

3927

1

			assert_eq!(

3928

1

				pre_call_candidate_info.total_counted,

3929

1

				post_call_candidate_info.total_counted

3930

1

);

3931

1

});

3932

1

3933

3934

#[test]

3935

1

fn execute_delegator_bond_less_does_not_delete_bottom_delegations() {

3936

1

	ExtBuilder::default()

3937

1

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

3938

1

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

3939

1

		.with_delegations(vec![

3940

1

			(2, 1, 10),

3941

1

			(3, 1, 11),

3942

1

			(4, 1, 12),

3943

1

			(5, 1, 14),

3944

1

			(6, 1, 15),

3945

1

])

3946

1

		.build()

3947

1

		.execute_with(|| {

3948

1

			let pre_call_candidate_info =

3949

1

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

3950

1

			let pre_call_top_delegations =

3951

1

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

3952

1

			let pre_call_bottom_delegations =

3953

1

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

3954

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

3955

1

				RuntimeOrigin::signed(6),

3956

1

1,

3957

1

3958

1

));

3959

1

			roll_to(10);

3960

1

			assert_ok!(ParachainStaking::execute_delegation_request(

3961

1

				RuntimeOrigin::signed(6),

3962

1

6,

3963

1

3964

1

));

3965

1

			let post_call_candidate_info =

3966

1

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

3967

1

			let post_call_top_delegations =

3968

1

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

3969

1

			let post_call_bottom_delegations =

3970

1

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

3971

1

			let mut equal = true;

3972

2

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

3973

				for Bond {

3974

1

					owner: post_owner,

3975

1

					amount: post_amount,

3976

2

				} in &post_call_bottom_delegations.delegations

3977

3978

1

					if &owner == post_owner {

3979

1

						if &amount != post_amount {

3980

							equal = false;

3981

							break;

3982

1

3983

3984

3985

3986

1

			assert!(equal);

3987

1

			let mut not_equal = false;

3988

5

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

3989

				for Bond {

3990

15

					owner: post_owner,

3991

15

					amount: post_amount,

3992

18

				} in &post_call_top_delegations.delegations

3993

3994

15

					if &owner == post_owner {

3995

4

						if &amount != post_amount {

3996

1

							not_equal = true;

3997

1

							break;

3998

3

3999

11

4000

4001

4002

1

			assert!(not_equal);

4003

1

			assert_eq!(

4004

1

				pre_call_candidate_info.total_counted - 4,

4005

1

				post_call_candidate_info.total_counted

4006

1

);

4007

1

});

4008

1

4009

4010

#[test]

4011

1

fn can_execute_delegator_bond_less_for_leaving_candidate() {

4012

1

	ExtBuilder::default()

4013

1

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

4014

1

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

4015

1

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

4016

1

		.build()

4017

1

		.execute_with(|| {

4018

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

4019

1

				RuntimeOrigin::signed(1),

4020

1

4021

1

));

4022

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

4023

1

				RuntimeOrigin::signed(2),

4024

1

1,

4025

1

4026

1

));

4027

1

			roll_to(10);

4028

1

			// can execute bond more delegation request for leaving candidate

4029

1

			assert_ok!(ParachainStaking::execute_delegation_request(

4030

1

				RuntimeOrigin::signed(2),

4031

1

2,

4032

1

4033

1

));

4034

1

});

4035

1

4036

4037

// CANCEL PENDING DELEGATION REQUEST

4038

// 1. CANCEL REVOKE DELEGATION

4039

4040

#[test]

4041

1

fn cancel_revoke_delegation_emits_correct_event() {

4042

1

	ExtBuilder::default()

4043

1

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

4044

1

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

4045

1

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

4046

1

		.build()

4047

1

		.execute_with(|| {

4048

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4049

1

				RuntimeOrigin::signed(2),

4050

1

4051

1

));

4052

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

4053

1

				RuntimeOrigin::signed(2),

4054

1

4055

1

));

4056

1

			assert_events_emitted!(Event::CancelledDelegationRequest {

4057

1

				delegator: 2,

4058

1

				collator: 1,

4059

1

				cancelled_request: CancelledScheduledRequest {

4060

1

					when_executable: 3,

4061

1

					action: DelegationAction::Revoke(10),

4062

1

},

4063

1

});

4064

1

});

4065

1

4066

4067

#[test]

4068

1

fn cancel_revoke_delegation_updates_delegator_state() {

4069

1

	ExtBuilder::default()

4070

1

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

4071

1

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

4072

1

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

4073

1

		.build()

4074

1

		.execute_with(|| {

4075

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4076

1

				RuntimeOrigin::signed(2),

4077

1

4078

1

));

4079

1

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

4080

1

			assert_eq!(

4081

1

				state,

4082

1

				vec![ScheduledRequest {

4083

1

					delegator: 2,

4084

1

					when_executable: 3,

4085

1

					action: DelegationAction::Revoke(10),

4086

1

}],

4087

1

);

4088

1

			assert_eq!(

4089

1

				ParachainStaking::delegator_state(&2)

4090

1

					.map(|x| x.less_total)

4091

1

					.expect("delegator state must exist"),

4092

1

4093

1

);

4094

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

4095

1

				RuntimeOrigin::signed(2),

4096

1

4097

1

));

4098

1

			assert!(!ParachainStaking::delegation_scheduled_requests(&1)

4099

1

				.iter()

4100

1

				.any(|x| x.delegator == 2));

4101

1

			assert_eq!(

4102

1

				ParachainStaking::delegator_state(&2)

4103

1

					.map(|x| x.less_total)

4104

1

					.expect("delegator state must exist"),

4105

1

4106

1

);

4107

1

});

4108

1

4109

4110

// 2. CANCEL DELEGATOR BOND LESS

4111

4112

#[test]

4113

1

fn cancel_delegator_bond_less_correct_event() {

4114

1

	ExtBuilder::default()

4115

1

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

4116

1

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

4117

1

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

4118

1

		.build()

4119

1

		.execute_with(|| {

4120

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

4121

1

				RuntimeOrigin::signed(2),

4122

1

1,

4123

1

4124

1

));

4125

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

4126

1

				RuntimeOrigin::signed(2),

4127

1

4128

1

));

4129

1

			assert_events_emitted!(Event::CancelledDelegationRequest {

4130

1

				delegator: 2,

4131

1

				collator: 1,

4132

1

				cancelled_request: CancelledScheduledRequest {

4133

1

					when_executable: 3,

4134

1

					action: DelegationAction::Decrease(5),

4135

1

},

4136

1

});

4137

1

});

4138

1

4139

4140

#[test]

4141

1

fn cancel_delegator_bond_less_updates_delegator_state() {

4142

1

	ExtBuilder::default()

4143

1

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

4144

1

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

4145

1

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

4146

1

		.build()

4147

1

		.execute_with(|| {

4148

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

4149

1

				RuntimeOrigin::signed(2),

4150

1

1,

4151

1

4152

1

));

4153

1

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

4154

1

			assert_eq!(

4155

1

				state,

4156

1

				vec![ScheduledRequest {

4157

1

					delegator: 2,

4158

1

					when_executable: 3,

4159

1

					action: DelegationAction::Decrease(5),

4160

1

}],

4161

1

);

4162

1

			assert_eq!(

4163

1

				ParachainStaking::delegator_state(&2)

4164

1

					.map(|x| x.less_total)

4165

1

					.expect("delegator state must exist"),

4166

1

4167

1

);

4168

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

4169

1

				RuntimeOrigin::signed(2),

4170

1

4171

1

));

4172

1

			assert!(!ParachainStaking::delegation_scheduled_requests(&1)

4173

1

				.iter()

4174

1

				.any(|x| x.delegator == 2));

4175

1

			assert_eq!(

4176

1

				ParachainStaking::delegator_state(&2)

4177

1

					.map(|x| x.less_total)

4178

1

					.expect("delegator state must exist"),

4179

1

4180

1

);

4181

1

});

4182

1

4183

4184

// ~~ PROPERTY-BASED TESTS ~~

4185

4186

#[test]

4187

1

fn delegator_schedule_revocation_total() {

4188

1

	ExtBuilder::default()

4189

1

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

4190

1

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

4191

1

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

4192

1

		.build()

4193

1

		.execute_with(|| {

4194

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4195

1

				RuntimeOrigin::signed(2),

4196

1

4197

1

));

4198

1

			assert_eq!(

4199

1

				ParachainStaking::delegator_state(&2)

4200

1

					.map(|x| x.less_total)

4201

1

					.expect("delegator state must exist"),

4202

1

4203

1

);

4204

1

			roll_to(10);

4205

1

			assert_ok!(ParachainStaking::execute_delegation_request(

4206

1

				RuntimeOrigin::signed(2),

4207

1

2,

4208

1

4209

1

));

4210

1

			assert_eq!(

4211

1

				ParachainStaking::delegator_state(&2)

4212

1

					.map(|x| x.less_total)

4213

1

					.expect("delegator state must exist"),

4214

1

4215

1

);

4216

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4217

1

				RuntimeOrigin::signed(2),

4218

1

5,

4219

1

10,

4220

1

				Percent::zero(),

4221

1

0,

4222

1

0,

4223

1

4224

1

));

4225

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4226

1

				RuntimeOrigin::signed(2),

4227

1

4228

1

));

4229

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4230

1

				RuntimeOrigin::signed(2),

4231

1

4232

1

));

4233

1

			assert_eq!(

4234

1

				ParachainStaking::delegator_state(&2)

4235

1

					.map(|x| x.less_total)

4236

1

					.expect("delegator state must exist"),

4237

1

20,

4238

1

);

4239

1

			roll_to(20);

4240

1

			assert_ok!(ParachainStaking::execute_delegation_request(

4241

1

				RuntimeOrigin::signed(2),

4242

1

2,

4243

1

4244

1

));

4245

1

			assert_eq!(

4246

1

				ParachainStaking::delegator_state(&2)

4247

1

					.map(|x| x.less_total)

4248

1

					.expect("delegator state must exist"),

4249

1

10,

4250

1

);

4251

1

			assert_ok!(ParachainStaking::execute_delegation_request(

4252

1

				RuntimeOrigin::signed(2),

4253

1

2,

4254

1

4255

1

));

4256

1

			assert_eq!(

4257

1

				ParachainStaking::delegator_state(&2)

4258

1

					.map(|x| x.less_total)

4259

1

					.expect("delegator state must exist"),

4260

1

4261

1

);

4262

1

});

4263

1

4264

4265

#[ignore]

4266

#[test]

4267

fn parachain_bond_inflation_reserve_matches_config() {

4268

	ExtBuilder::default()

4269

		.with_balances(vec![

4270

			(1, 100),

4271

			(2, 100),

4272

			(3, 100),

4273

			(4, 100),

4274

			(5, 100),

4275

			(6, 100),

4276

			(7, 100),

4277

			(8, 100),

4278

			(9, 100),

4279

			(10, 100),

4280

			(11, 1),

4281

])

4282

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

4283

		.with_delegations(vec![

4284

			(6, 1, 10),

4285

			(7, 1, 10),

4286

			(8, 2, 10),

4287

			(9, 2, 10),

4288

			(10, 1, 10),

4289

])

4290

		.build()

4291

		.execute_with(|| {

4292

			assert_eq!(Balances::free_balance(&11), 1);

4293

			// set parachain bond account so DefaultParachainBondReservePercent = 30% of inflation

4294

			// is allocated to this account hereafter

4295

			assert_ok!(ParachainStaking::set_parachain_bond_account(

4296

				RuntimeOrigin::root(),

4297

4298

));

4299

			assert_events_eq!(Event::InflationDistributionConfigUpdated {

4300

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

4301

				new: inflation_configs(11, 30, 0, 0),

4302

});

4303

			roll_to_round_begin(2);

4304

			// chooses top TotalSelectedCandidates (5), in order

4305

			assert_events_eq!(

4306

				Event::CollatorChosen {

4307

					round: 2,

4308

					collator_account: 1,

4309

					total_exposed_amount: 50,

4310

},

4311

				Event::CollatorChosen {

4312

					round: 2,

4313

					collator_account: 2,

4314

					total_exposed_amount: 40,

4315

},

4316

				Event::CollatorChosen {

4317

					round: 2,

4318

					collator_account: 3,

4319

					total_exposed_amount: 20,

4320

},

4321

				Event::CollatorChosen {

4322

					round: 2,

4323

					collator_account: 4,

4324

					total_exposed_amount: 20,

4325

},

4326

				Event::CollatorChosen {

4327

					round: 2,

4328

					collator_account: 5,

4329

					total_exposed_amount: 10,

4330

},

4331

				Event::NewRound {

4332

					starting_block: 5,

4333

					round: 2,

4334

					selected_collators_number: 5,

4335

					total_balance: 140,

4336

},

4337

);

4338

			assert_eq!(Balances::free_balance(&11), 1);

4339

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

4340

			set_author(2, 1, POINTS_PER_ROUND);

4341

			roll_to_round_begin(4);

4342

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

4343

			assert_eq!(Balances::free_balance(&11), 16);

4344

			// ~ set block author as 1 for all blocks in rounds 3, 4, and 5

4345

			set_author(3, 1, POINTS_PER_ROUND);

4346

			set_author(4, 1, POINTS_PER_ROUND);

4347

			set_author(5, 1, POINTS_PER_ROUND);

4348

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

4349

			assert_noop!(

4350

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

4351

				Error::<Test>::DelegatorDNE

4352

);

4353

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

4354

				RuntimeOrigin::signed(6),

4355

1,

4356

));

4357

			assert_events_eq!(

4358

				Event::InflationDistributed {

4359

					index: 0,

4360

					account: 11, // PBR

4361

					value: 15,

4362

},

4363

				Event::InflationDistributed {

4364

					index: 1,

4365

					account: 0, // Treasury

4366

					value: 0,

4367

},

4368

				Event::CollatorChosen {

4369

					round: 4,

4370

					collator_account: 1,

4371

					total_exposed_amount: 50,

4372

},

4373

				Event::CollatorChosen {

4374

					round: 4,

4375

					collator_account: 2,

4376

					total_exposed_amount: 40,

4377

},

4378

				Event::CollatorChosen {

4379

					round: 4,

4380

					collator_account: 3,

4381

					total_exposed_amount: 20,

4382

},

4383

				Event::CollatorChosen {

4384

					round: 4,

4385

					collator_account: 4,

4386

					total_exposed_amount: 20,

4387

},

4388

				Event::CollatorChosen {

4389

					round: 4,

4390

					collator_account: 5,

4391

					total_exposed_amount: 10,

4392

},

4393

				Event::NewRound {

4394

					starting_block: 15,

4395

					round: 4,

4396

					selected_collators_number: 5,

4397

					total_balance: 140,

4398

},

4399

				Event::DelegatorExitScheduled {

4400

					round: 4,

4401

					delegator: 6,

4402

					scheduled_exit: 6,

4403

},

4404

);

4405

			roll_blocks(3);

4406

			assert_events_eq!(

4407

				Event::Rewarded {

4408

					account: 1,

4409

					rewards: 20,

4410

},

4411

				Event::Rewarded {

4412

					account: 6,

4413

					rewards: 5,

4414

},

4415

				Event::Rewarded {

4416

					account: 7,

4417

					rewards: 5,

4418

},

4419

				Event::Rewarded {

4420

					account: 10,

4421

					rewards: 5,

4422

},

4423

);

4424

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

4425

			roll_to_round_begin(5);

4426

			assert_events_eq!(

4427

				Event::InflationDistributed {

4428

					index: 0,

4429

					account: 11, // PBR

4430

					value: 16,

4431

},

4432

				Event::InflationDistributed {

4433

					index: 1,

4434

					account: 0, // Treasury

4435

					value: 0,

4436

},

4437

				Event::CollatorChosen {

4438

					round: 5,

4439

					collator_account: 1,

4440

					total_exposed_amount: 50,

4441

},

4442

				Event::CollatorChosen {

4443

					round: 5,

4444

					collator_account: 2,

4445

					total_exposed_amount: 40,

4446

},

4447

				Event::CollatorChosen {

4448

					round: 5,

4449

					collator_account: 3,

4450

					total_exposed_amount: 20,

4451

},

4452

				Event::CollatorChosen {

4453

					round: 5,

4454

					collator_account: 4,

4455

					total_exposed_amount: 20,

4456

},

4457

				Event::CollatorChosen {

4458

					round: 5,

4459

					collator_account: 5,

4460

					total_exposed_amount: 10,

4461

},

4462

				Event::NewRound {

4463

					starting_block: 20,

4464

					round: 5,

4465

					selected_collators_number: 5,

4466

					total_balance: 140,

4467

},

4468

);

4469

			roll_blocks(3);

4470

			assert_events_eq!(

4471

				Event::Rewarded {

4472

					account: 1,

4473

					rewards: 21,

4474

},

4475

				Event::Rewarded {

4476

					account: 6,

4477

					rewards: 5,

4478

},

4479

				Event::Rewarded {

4480

					account: 7,

4481

					rewards: 5,

4482

},

4483

				Event::Rewarded {

4484

					account: 10,

4485

					rewards: 5,

4486

},

4487

);

4488

			roll_to_round_begin(6);

4489

			assert_ok!(ParachainStaking::execute_delegation_request(

4490

				RuntimeOrigin::signed(6),

4491

6,

4492

4493

));

4494

			assert_events_eq!(

4495

				Event::InflationDistributed {

4496

					index: 0,

4497

					account: 11, // PBR

4498

					value: 16,

4499

},

4500

				Event::InflationDistributed {

4501

					index: 1,

4502

					account: 0, // Treasury

4503

					value: 0,

4504

},

4505

				Event::CollatorChosen {

4506

					round: 6,

4507

					collator_account: 1,

4508

					total_exposed_amount: 50,

4509

},

4510

				Event::CollatorChosen {

4511

					round: 6,

4512

					collator_account: 2,

4513

					total_exposed_amount: 40,

4514

},

4515

				Event::CollatorChosen {

4516

					round: 6,

4517

					collator_account: 3,

4518

					total_exposed_amount: 20,

4519

},

4520

				Event::CollatorChosen {

4521

					round: 6,

4522

					collator_account: 4,

4523

					total_exposed_amount: 20,

4524

},

4525

				Event::CollatorChosen {

4526

					round: 6,

4527

					collator_account: 5,

4528

					total_exposed_amount: 10,

4529

},

4530

				Event::NewRound {

4531

					starting_block: 25,

4532

					round: 6,

4533

					selected_collators_number: 5,

4534

					total_balance: 140,

4535

},

4536

				Event::DelegatorLeftCandidate {

4537

					delegator: 6,

4538

					candidate: 1,

4539

					unstaked_amount: 10,

4540

					total_candidate_staked: 40,

4541

},

4542

				Event::DelegatorLeft {

4543

					delegator: 6,

4544

					unstaked_amount: 10,

4545

},

4546

);

4547

			roll_blocks(3);

4548

			assert_events_eq!(

4549

				Event::Rewarded {

4550

					account: 1,

4551

					rewards: 22,

4552

},

4553

				Event::Rewarded {

4554

					account: 6,

4555

					rewards: 6,

4556

},

4557

				Event::Rewarded {

4558

					account: 7,

4559

					rewards: 6,

4560

},

4561

				Event::Rewarded {

4562

					account: 10,

4563

					rewards: 6,

4564

},

4565

);

4566

			roll_to_round_begin(7);

4567

			assert_events_eq!(

4568

				Event::InflationDistributed {

4569

					index: 0,

4570

					account: 11, // PBR

4571

					value: 17,

4572

},

4573

				Event::InflationDistributed {

4574

					index: 1,

4575

					account: 0, // Treasury

4576

					value: 0,

4577

},

4578

				Event::CollatorChosen {

4579

					round: 7,

4580

					collator_account: 1,

4581

					total_exposed_amount: 40,

4582

},

4583

				Event::CollatorChosen {

4584

					round: 7,

4585

					collator_account: 2,

4586

					total_exposed_amount: 40,

4587

},

4588

				Event::CollatorChosen {

4589

					round: 7,

4590

					collator_account: 3,

4591

					total_exposed_amount: 20,

4592

},

4593

				Event::CollatorChosen {

4594

					round: 7,

4595

					collator_account: 4,

4596

					total_exposed_amount: 20,

4597

},

4598

				Event::CollatorChosen {

4599

					round: 7,

4600

					collator_account: 5,

4601

					total_exposed_amount: 10,

4602

},

4603

				Event::NewRound {

4604

					starting_block: 30,

4605

					round: 7,

4606

					selected_collators_number: 5,

4607

					total_balance: 130,

4608

},

4609

);

4610

			roll_blocks(3);

4611

			assert_events_eq!(

4612

				Event::Rewarded {

4613

					account: 1,

4614

					rewards: 26,

4615

},

4616

				Event::Rewarded {

4617

					account: 7,

4618

					rewards: 7,

4619

},

4620

				Event::Rewarded {

4621

					account: 10,

4622

					rewards: 7,

4623

},

4624

);

4625

			assert_eq!(Balances::free_balance(&11), 65);

4626

			roll_blocks(1);

4627

			assert_ok!(ParachainStaking::set_parachain_bond_reserve_percent(

4628

				RuntimeOrigin::root(),

4629

				Percent::from_percent(50)

4630

));

4631

			assert_events_eq!(Event::InflationDistributionConfigUpdated {

4632

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

4633

				new: inflation_configs(11, 50, 0, 0),

4634

});

4635

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

4636

			set_author(6, 1, POINTS_PER_ROUND);

4637

			roll_to_round_begin(8);

4638

			// keep paying 6

4639

			assert_events_eq!(

4640

				Event::InflationDistributed {

4641

					index: 0,

4642

					account: 11, // PBR

4643

					value: 30,

4644

},

4645

				Event::InflationDistributed {

4646

					index: 1,

4647

					account: 0, // Treasury

4648

					value: 0,

4649

},

4650

				Event::CollatorChosen {

4651

					round: 8,

4652

					collator_account: 1,

4653

					total_exposed_amount: 40,

4654

},

4655

				Event::CollatorChosen {

4656

					round: 8,

4657

					collator_account: 2,

4658

					total_exposed_amount: 40,

4659

},

4660

				Event::CollatorChosen {

4661

					round: 8,

4662

					collator_account: 3,

4663

					total_exposed_amount: 20,

4664

},

4665

				Event::CollatorChosen {

4666

					round: 8,

4667

					collator_account: 4,

4668

					total_exposed_amount: 20,

4669

},

4670

				Event::CollatorChosen {

4671

					round: 8,

4672

					collator_account: 5,

4673

					total_exposed_amount: 10,

4674

},

4675

				Event::NewRound {

4676

					starting_block: 35,

4677

					round: 8,

4678

					selected_collators_number: 5,

4679

					total_balance: 130,

4680

},

4681

);

4682

			roll_blocks(3);

4683

			assert_events_eq!(

4684

				Event::Rewarded {

4685

					account: 1,

4686

					rewards: 21,

4687

},

4688

				Event::Rewarded {

4689

					account: 7,

4690

					rewards: 5,

4691

},

4692

				Event::Rewarded {

4693

					account: 10,

4694

					rewards: 5,

4695

},

4696

);

4697

			assert_eq!(Balances::free_balance(&11), 95);

4698

			set_author(7, 1, POINTS_PER_ROUND);

4699

			roll_to_round_begin(9);

4700

			// no more paying 6

4701

			assert_events_eq!(

4702

				Event::InflationDistributed {

4703

					index: 0,

4704

					account: 11, // PBR

4705

					value: 32,

4706

},

4707

				Event::InflationDistributed {

4708

					index: 1,

4709

					account: 0, // Treasury

4710

					value: 0,

4711

},

4712

				Event::CollatorChosen {

4713

					round: 9,

4714

					collator_account: 1,

4715

					total_exposed_amount: 40,

4716

},

4717

				Event::CollatorChosen {

4718

					round: 9,

4719

					collator_account: 2,

4720

					total_exposed_amount: 40,

4721

},

4722

				Event::CollatorChosen {

4723

					round: 9,

4724

					collator_account: 3,

4725

					total_exposed_amount: 20,

4726

},

4727

				Event::CollatorChosen {

4728

					round: 9,

4729

					collator_account: 4,

4730

					total_exposed_amount: 20,

4731

},

4732

				Event::CollatorChosen {

4733

					round: 9,

4734

					collator_account: 5,

4735

					total_exposed_amount: 10,

4736

},

4737

				Event::NewRound {

4738

					starting_block: 40,

4739

					round: 9,

4740

					selected_collators_number: 5,

4741

					total_balance: 130,

4742

},

4743

);

4744

			roll_blocks(3);

4745

			assert_events_eq!(

4746

				Event::Rewarded {

4747

					account: 1,

4748

					rewards: 22,

4749

},

4750

				Event::Rewarded {

4751

					account: 7,

4752

					rewards: 5,

4753

},

4754

				Event::Rewarded {

4755

					account: 10,

4756

					rewards: 5,

4757

},

4758

);

4759

			assert_eq!(Balances::free_balance(&11), 127);

4760

			set_author(8, 1, POINTS_PER_ROUND);

4761

			roll_blocks(1);

4762

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

4763

				RuntimeOrigin::signed(8),

4764

1,

4765

10,

4766

				Percent::zero(),

4767

10,

4768

0,

4769

4770

));

4771

			assert_events_eq!(Event::Delegation {

4772

				delegator: 8,

4773

				locked_amount: 10,

4774

				candidate: 1,

4775

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

4776

				auto_compound: Percent::zero(),

4777

});

4778

			roll_to_round_begin(10);

4779

			// new delegation is not rewarded yet

4780

			assert_events_eq!(

4781

				Event::InflationDistributed {

4782

					index: 0,

4783

					account: 11, // PBR

4784

					value: 33,

4785

},

4786

				Event::InflationDistributed {

4787

					index: 1,

4788

					account: 0, // Treasury

4789

					value: 0,

4790

},

4791

				Event::CollatorChosen {

4792

					round: 10,

4793

					collator_account: 1,

4794

					total_exposed_amount: 50,

4795

},

4796

				Event::CollatorChosen {

4797

					round: 10,

4798

					collator_account: 2,

4799

					total_exposed_amount: 40,

4800

},

4801

				Event::CollatorChosen {

4802

					round: 10,

4803

					collator_account: 3,

4804

					total_exposed_amount: 20,

4805

},

4806

				Event::CollatorChosen {

4807

					round: 10,

4808

					collator_account: 4,

4809

					total_exposed_amount: 20,

4810

},

4811

				Event::CollatorChosen {

4812

					round: 10,

4813

					collator_account: 5,

4814

					total_exposed_amount: 10,

4815

},

4816

				Event::NewRound {

4817

					starting_block: 45,

4818

					round: 10,

4819

					selected_collators_number: 5,

4820

					total_balance: 140,

4821

},

4822

);

4823

			roll_blocks(3);

4824

			assert_events_eq!(

4825

				Event::Rewarded {

4826

					account: 1,

4827

					rewards: 23,

4828

},

4829

				Event::Rewarded {

4830

					account: 7,

4831

					rewards: 5,

4832

},

4833

				Event::Rewarded {

4834

					account: 10,

4835

					rewards: 5,

4836

},

4837

);

4838

			assert_eq!(Balances::free_balance(&11), 160);

4839

			set_author(9, 1, POINTS_PER_ROUND);

4840

			set_author(10, 1, POINTS_PER_ROUND);

4841

			roll_to_round_begin(11);

4842

			// new delegation is still not rewarded yet

4843

			assert_events_eq!(

4844

				Event::InflationDistributed {

4845

					index: 0,

4846

					account: 11, // PBR

4847

					value: 35,

4848

},

4849

				Event::InflationDistributed {

4850

					index: 1,

4851

					account: 0, // Treasury

4852

					value: 0,

4853

},

4854

				Event::CollatorChosen {

4855

					round: 11,

4856

					collator_account: 1,

4857

					total_exposed_amount: 50,

4858

},

4859

				Event::CollatorChosen {

4860

					round: 11,

4861

					collator_account: 2,

4862

					total_exposed_amount: 40,

4863

},

4864

				Event::CollatorChosen {

4865

					round: 11,

4866

					collator_account: 3,

4867

					total_exposed_amount: 20,

4868

},

4869

				Event::CollatorChosen {

4870

					round: 11,

4871

					collator_account: 4,

4872

					total_exposed_amount: 20,

4873

},

4874

				Event::CollatorChosen {

4875

					round: 11,

4876

					collator_account: 5,

4877

					total_exposed_amount: 10,

4878

},

4879

				Event::NewRound {

4880

					starting_block: 50,

4881

					round: 11,

4882

					selected_collators_number: 5,

4883

					total_balance: 140,

4884

},

4885

);

4886

			roll_blocks(3);

4887

			assert_events_eq!(

4888

				Event::Rewarded {

4889

					account: 1,

4890

					rewards: 24,

4891

},

4892

				Event::Rewarded {

4893

					account: 7,

4894

					rewards: 5,

4895

},

4896

				Event::Rewarded {

4897

					account: 10,

4898

					rewards: 5,

4899

},

4900

);

4901

			assert_eq!(Balances::free_balance(&11), 195);

4902

			roll_to_round_begin(12);

4903

			// new delegation is rewarded, 2 rounds after joining (`RewardPaymentDelay` is 2)

4904

			assert_events_eq!(

4905

				Event::InflationDistributed {

4906

					index: 0,

4907

					account: 11, // PBR

4908

					value: 37,

4909

},

4910

				Event::InflationDistributed {

4911

					index: 1,

4912

					account: 0, // Treasury

4913

					value: 0,

4914

},

4915

				Event::CollatorChosen {

4916

					round: 12,

4917

					collator_account: 1,

4918

					total_exposed_amount: 50,

4919

},

4920

				Event::CollatorChosen {

4921

					round: 12,

4922

					collator_account: 2,

4923

					total_exposed_amount: 40,

4924

},

4925

				Event::CollatorChosen {

4926

					round: 12,

4927

					collator_account: 3,

4928

					total_exposed_amount: 20,

4929

},

4930

				Event::CollatorChosen {

4931

					round: 12,

4932

					collator_account: 4,

4933

					total_exposed_amount: 20,

4934

},

4935

				Event::CollatorChosen {

4936

					round: 12,

4937

					collator_account: 5,

4938

					total_exposed_amount: 10,

4939

},

4940

				Event::NewRound {

4941

					starting_block: 55,

4942

					round: 12,

4943

					selected_collators_number: 5,

4944

					total_balance: 140,

4945

},

4946

);

4947

			roll_blocks(3);

4948

			assert_events_eq!(

4949

				Event::Rewarded {

4950

					account: 1,

4951

					rewards: 24,

4952

},

4953

				Event::Rewarded {

4954

					account: 7,

4955

					rewards: 4,

4956

},

4957

				Event::Rewarded {

4958

					account: 10,

4959

					rewards: 4,

4960

},

4961

				Event::Rewarded {

4962

					account: 8,

4963

					rewards: 4,

4964

},

4965

);

4966

			assert_eq!(Balances::free_balance(&11), 232);

4967

});

4968

4969

4970

#[test]

4971

1

fn paid_collator_commission_matches_config() {

4972

1

	ExtBuilder::default()

4973

1

		.with_balances(vec![

4974

1

			(1, 100),

4975

1

			(2, 100),

4976

1

			(3, 100),

4977

1

			(4, 100),

4978

1

			(5, 100),

4979

1

			(6, 100),

4980

1

])

4981

1

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

4982

1

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

4983

1

		.build()

4984

1

		.execute_with(|| {

4985

1

			roll_to_round_begin(2);

4986

1

			assert_ok!(ParachainStaking::join_candidates(

4987

1

				RuntimeOrigin::signed(4),

4988

1

				20u128,

4989

1

				100u32

4990

1

));

4991

1

			assert_events_eq!(

4992

1

				Event::CollatorChosen {

4993

1

					round: 2,

4994

1

					collator_account: 1,

4995

1

					total_exposed_amount: 40,

4996

1

},

4997

1

				Event::NewRound {

4998

1

					starting_block: 5,

4999

1

					round: 2,

5000

1

					selected_collators_number: 1,

5001

1

					total_balance: 40,

5002

1

},

5003

1

				Event::JoinedCollatorCandidates {

5004

1

					account: 4,

5005

1

					amount_locked: 20,

5006

1

					new_total_amt_locked: 60,

5007

1

},

5008

1

);

5009

5010

1

			roll_blocks(1);

5011

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5012

1

				RuntimeOrigin::signed(5),

5013

1

4,

5014

1

10,

5015

1

				Percent::zero(),

5016

1

10,

5017

1

0,

5018

1

5019

1

));

5020

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5021

1

				RuntimeOrigin::signed(6),

5022

1

4,

5023

1

10,

5024

1

				Percent::zero(),

5025

1

10,

5026

1

0,

5027

1

5028

1

));

5029

1

			assert_events_eq!(

5030

1

				Event::Delegation {

5031

1

					delegator: 5,

5032

1

					locked_amount: 10,

5033

1

					candidate: 4,

5034

1

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

5035

1

					auto_compound: Percent::zero(),

5036

1

},

5037

1

				Event::Delegation {

5038

1

					delegator: 6,

5039

1

					locked_amount: 10,

5040

1

					candidate: 4,

5041

1

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

5042

1

					auto_compound: Percent::zero(),

5043

1

},

5044

1

);

5045

5046

1

			roll_to_round_begin(3);

5047

1

			assert_events_eq!(

5048

1

				Event::CollatorChosen {

5049

1

					round: 3,

5050

1

					collator_account: 1,

5051

1

					total_exposed_amount: 40,

5052

1

},

5053

1

				Event::CollatorChosen {

5054

1

					round: 3,

5055

1

					collator_account: 4,

5056

1

					total_exposed_amount: 40,

5057

1

},

5058

1

				Event::NewRound {

5059

1

					starting_block: 10,

5060

1

					round: 3,

5061

1

					selected_collators_number: 2,

5062

1

					total_balance: 80,

5063

1

},

5064

1

);

5065

			// only reward author with id 4

5066

1

			set_author(3, 4, POINTS_PER_ROUND);

5067

1

			roll_to_round_begin(5);

5068

1

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

5069

1

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

5070

1

			assert_events_eq!(

5071

1

				Event::CollatorChosen {

5072

1

					round: 5,

5073

1

					collator_account: 1,

5074

1

					total_exposed_amount: 40,

5075

1

},

5076

1

				Event::CollatorChosen {

5077

1

					round: 5,

5078

1

					collator_account: 4,

5079

1

					total_exposed_amount: 40,

5080

1

},

5081

1

				Event::NewRound {

5082

1

					starting_block: 20,

5083

1

					round: 5,

5084

1

					selected_collators_number: 2,

5085

1

					total_balance: 80,

5086

1

},

5087

1

);

5088

5089

1

			roll_blocks(1);

5090

1

			assert_events_eq!(

5091

1

				Event::Rewarded {

5092

1

					account: 4,

5093

1

					rewards: 9,

5094

1

},

5095

1

				Event::Rewarded {

5096

1

					account: 5,

5097

1

					rewards: 3,

5098

1

},

5099

1

				Event::Rewarded {

5100

1

					account: 6,

5101

1

					rewards: 3,

5102

1

},

5103

1

);

5104

1

});

5105

1

5106

5107

#[test]

5108

1

fn collator_exit_executes_after_delay() {

5109

1

	ExtBuilder::default()

5110

1

		.with_balances(vec![

5111

1

			(1, 1000),

5112

1

			(2, 300),

5113

1

			(3, 100),

5114

1

			(4, 100),

5115

1

			(5, 100),

5116

1

			(6, 100),

5117

1

			(7, 100),

5118

1

			(8, 9),

5119

1

			(9, 4),

5120

1

])

5121

1

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

5122

1

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

5123

1

		.build()

5124

1

		.execute_with(|| {

5125

1

			roll_to(11);

5126

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

5127

1

				RuntimeOrigin::signed(2),

5128

1

5129

1

));

5130

1

			assert_events_eq!(Event::CandidateScheduledExit {

5131

1

				exit_allowed_round: 3,

5132

1

				candidate: 2,

5133

1

				scheduled_exit: 5,

5134

1

});

5135

1

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

5136

1

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

5137

1

			roll_to(21);

5138

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

5139

1

				RuntimeOrigin::signed(2),

5140

1

2,

5141

1

5142

1

));

5143

			// we must exclude leaving collators from rewards while

5144

			// holding them retroactively accountable for previous faults

5145

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

5146

1

			assert_events_eq!(Event::CandidateLeft {

5147

1

				ex_candidate: 2,

5148

1

				unlocked_amount: 400,

5149

1

				new_total_amt_locked: 700,

5150

1

			},);

5151

1

});

5152

1

5153

5154

#[test]

5155

1

fn collator_selection_chooses_top_candidates() {

5156

1

	ExtBuilder::default()

5157

1

		.with_balances(vec![

5158

1

			(1, 1000),

5159

1

			(2, 1000),

5160

1

			(3, 1000),

5161

1

			(4, 1000),

5162

1

			(5, 1000),

5163

1

			(6, 1000),

5164

1

			(7, 33),

5165

1

			(8, 33),

5166

1

			(9, 33),

5167

1

])

5168

1

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

5169

1

		.build()

5170

1

		.execute_with(|| {

5171

1

			roll_to_round_begin(2);

5172

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

5173

1

				RuntimeOrigin::signed(6),

5174

1

5175

1

));

5176

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

5177

1

			assert_events_eq!(

5178

1

				Event::CollatorChosen {

5179

1

					round: 2,

5180

1

					collator_account: 1,

5181

1

					total_exposed_amount: 100,

5182

1

},

5183

1

				Event::CollatorChosen {

5184

1

					round: 2,

5185

1

					collator_account: 2,

5186

1

					total_exposed_amount: 90,

5187

1

},

5188

1

				Event::CollatorChosen {

5189

1

					round: 2,

5190

1

					collator_account: 3,

5191

1

					total_exposed_amount: 80,

5192

1

},

5193

1

				Event::CollatorChosen {

5194

1

					round: 2,

5195

1

					collator_account: 4,

5196

1

					total_exposed_amount: 70,

5197

1

},

5198

1

				Event::CollatorChosen {

5199

1

					round: 2,

5200

1

					collator_account: 5,

5201

1

					total_exposed_amount: 60,

5202

1

},

5203

1

				Event::NewRound {

5204

1

					starting_block: 5,

5205

1

					round: 2,

5206

1

					selected_collators_number: 5,

5207

1

					total_balance: 400,

5208

1

},

5209

1

				Event::CandidateScheduledExit {

5210

1

					exit_allowed_round: 2,

5211

1

					candidate: 6,

5212

1

					scheduled_exit: 4

5213

1

},

5214

1

);

5215

1

			roll_to_round_begin(4);

5216

1

			roll_blocks(1);

5217

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

5218

1

				RuntimeOrigin::signed(6),

5219

1

6,

5220

1

5221

1

));

5222

1

			assert_ok!(ParachainStaking::join_candidates(

5223

1

				RuntimeOrigin::signed(6),

5224

1

				69u128,

5225

1

				100u32

5226

1

));

5227

1

			assert_events_eq!(

5228

1

				Event::CandidateLeft {

5229

1

					ex_candidate: 6,

5230

1

					unlocked_amount: 50,

5231

1

					new_total_amt_locked: 400,

5232

1

},

5233

1

				Event::JoinedCollatorCandidates {

5234

1

					account: 6,

5235

1

					amount_locked: 69u128,

5236

1

					new_total_amt_locked: 469u128,

5237

1

},

5238

1

);

5239

1

			roll_to_round_begin(6);

5240

1

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

5241

1

			assert_events_eq!(

5242

1

				Event::CollatorChosen {

5243

1

					round: 6,

5244

1

					collator_account: 1,

5245

1

					total_exposed_amount: 100,

5246

1

},

5247

1

				Event::CollatorChosen {

5248

1

					round: 6,

5249

1

					collator_account: 2,

5250

1

					total_exposed_amount: 90,

5251

1

},

5252

1

				Event::CollatorChosen {

5253

1

					round: 6,

5254

1

					collator_account: 3,

5255

1

					total_exposed_amount: 80,

5256

1

},

5257

1

				Event::CollatorChosen {

5258

1

					round: 6,

5259

1

					collator_account: 4,

5260

1

					total_exposed_amount: 70,

5261

1

},

5262

1

				Event::CollatorChosen {

5263

1

					round: 6,

5264

1

					collator_account: 6,

5265

1

					total_exposed_amount: 69,

5266

1

},

5267

1

				Event::NewRound {

5268

1

					starting_block: 25,

5269

1

					round: 6,

5270

1

					selected_collators_number: 5,

5271

1

					total_balance: 409,

5272

1

},

5273

1

);

5274

1

});

5275

1

5276

5277

#[test]

5278

1

fn payout_distribution_to_solo_collators() {

5279

1

	ExtBuilder::default()

5280

1

		.with_balances(vec![

5281

1

			(1, 1000),

5282

1

			(2, 1000),

5283

1

			(3, 1000),

5284

1

			(4, 1000),

5285

1

			(7, 33),

5286

1

			(8, 33),

5287

1

			(9, 33),

5288

1

])

5289

1

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

5290

1

		.build()

5291

1

		.execute_with(|| {

5292

1

			roll_to_round_begin(2);

5293

1

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

5294

1

			assert_events_eq!(

5295

1

				Event::CollatorChosen {

5296

1

					round: 2,

5297

1

					collator_account: 1,

5298

1

					total_exposed_amount: 100,

5299

1

},

5300

1

				Event::CollatorChosen {

5301

1

					round: 2,

5302

1

					collator_account: 2,

5303

1

					total_exposed_amount: 90,

5304

1

},

5305

1

				Event::CollatorChosen {

5306

1

					round: 2,

5307

1

					collator_account: 3,

5308

1

					total_exposed_amount: 80,

5309

1

},

5310

1

				Event::CollatorChosen {

5311

1

					round: 2,

5312

1

					collator_account: 4,

5313

1

					total_exposed_amount: 70,

5314

1

},

5315

1

				Event::NewRound {

5316

1

					starting_block: 5,

5317

1

					round: 2,

5318

1

					selected_collators_number: 4,

5319

1

					total_balance: 340,

5320

1

},

5321

1

);

5322

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

5323

1

			set_author(2, 1, POINTS_PER_ROUND);

5324

1

			roll_to_round_begin(4);

5325

1

			assert_events_eq!(

5326

1

				Event::CollatorChosen {

5327

1

					round: 4,

5328

1

					collator_account: 1,

5329

1

					total_exposed_amount: 100,

5330

1

},

5331

1

				Event::CollatorChosen {

5332

1

					round: 4,

5333

1

					collator_account: 2,

5334

1

					total_exposed_amount: 90,

5335

1

},

5336

1

				Event::CollatorChosen {

5337

1

					round: 4,

5338

1

					collator_account: 3,

5339

1

					total_exposed_amount: 80,

5340

1

},

5341

1

				Event::CollatorChosen {

5342

1

					round: 4,

5343

1

					collator_account: 4,

5344

1

					total_exposed_amount: 70,

5345

1

},

5346

1

				Event::NewRound {

5347

1

					starting_block: 15,

5348

1

					round: 4,

5349

1

					selected_collators_number: 4,

5350

1

					total_balance: 340,

5351

1

},

5352

1

);

5353

			// pay total issuance to 1 at 2nd block

5354

1

			roll_blocks(3);

5355

1

			assert_events_eq!(Event::Rewarded {

5356

1

				account: 1,

5357

1

				rewards: 102,

5358

1

});

5359

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

5360

1

			set_author(4, 1, POINTS_PER_BLOCK * 3);

5361

1

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

5362

1

			set_author(4, 2, POINTS_PER_BLOCK * 2);

5363

1

			roll_to_round_begin(6);

5364

1

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

5365

1

			assert_events_eq!(

5366

1

				Event::CollatorChosen {

5367

1

					round: 6,

5368

1

					collator_account: 1,

5369

1

					total_exposed_amount: 100,

5370

1

},

5371

1

				Event::CollatorChosen {

5372

1

					round: 6,

5373

1

					collator_account: 2,

5374

1

					total_exposed_amount: 90,

5375

1

},

5376

1

				Event::CollatorChosen {

5377

1

					round: 6,

5378

1

					collator_account: 3,

5379

1

					total_exposed_amount: 80,

5380

1

},

5381

1

				Event::CollatorChosen {

5382

1

					round: 6,

5383

1

					collator_account: 4,

5384

1

					total_exposed_amount: 70,

5385

1

},

5386

1

				Event::NewRound {

5387

1

					starting_block: 25,

5388

1

					round: 6,

5389

1

					selected_collators_number: 4,

5390

1

					total_balance: 340,

5391

1

},

5392

1

);

5393

1

			roll_blocks(3);

5394

1

			assert_events_eq!(Event::Rewarded {

5395

1

				account: 1,

5396

1

				rewards: 63,

5397

1

});

5398

1

			roll_blocks(1);

5399

1

			assert_events_eq!(Event::Rewarded {

5400

1

				account: 2,

5401

1

				rewards: 42,

5402

1

			},);

5403

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

5404

1

			set_author(6, 1, POINTS_PER_BLOCK * 2);

5405

1

			set_author(6, 2, POINTS_PER_BLOCK);

5406

1

			set_author(6, 3, POINTS_PER_BLOCK);

5407

1

			set_author(6, 4, POINTS_PER_BLOCK);

5408

1

			roll_to_round_begin(8);

5409

1

			// pay 20% issuance for all collators

5410

1

			assert_events_eq!(

5411

1

				Event::CollatorChosen {

5412

1

					round: 8,

5413

1

					collator_account: 1,

5414

1

					total_exposed_amount: 100,

5415

1

},

5416

1

				Event::CollatorChosen {

5417

1

					round: 8,

5418

1

					collator_account: 2,

5419

1

					total_exposed_amount: 90,

5420

1

},

5421

1

				Event::CollatorChosen {

5422

1

					round: 8,

5423

1

					collator_account: 3,

5424

1

					total_exposed_amount: 80,

5425

1

},

5426

1

				Event::CollatorChosen {

5427

1

					round: 8,

5428

1

					collator_account: 4,

5429

1

					total_exposed_amount: 70,

5430

1

},

5431

1

				Event::NewRound {

5432

1

					starting_block: 35,

5433

1

					round: 8,

5434

1

					selected_collators_number: 4,

5435

1

					total_balance: 340,

5436

1

},

5437

1

);

5438

1

			roll_blocks(1);

5439

1

			assert_events_eq!(Event::Rewarded {

5440

1

				account: 3,

5441

1

				rewards: 21,

5442

1

});

5443

1

			roll_blocks(1);

5444

1

			assert_events_eq!(Event::Rewarded {

5445

1

				account: 4,

5446

1

				rewards: 21,

5447

1

});

5448

1

			roll_blocks(1);

5449

1

			assert_events_eq!(Event::Rewarded {

5450

1

				account: 1,

5451

1

				rewards: 43,

5452

1

});

5453

1

			roll_blocks(1);

5454

1

			assert_events_eq!(Event::Rewarded {

5455

1

				account: 2,

5456

1

				rewards: 21,

5457

1

});

5458

			// check that distributing rewards clears awarded pts

5459

1

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

5460

1

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

5461

1

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

5462

1

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

5463

1

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

5464

1

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

5465

1

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

5466

1

});

5467

1

5468

5469

#[test]

5470

1

fn multiple_delegations() {

5471

1

	ExtBuilder::default()

5472

1

		.with_balances(vec![

5473

1

			(1, 100),

5474

1

			(2, 100),

5475

1

			(3, 100),

5476

1

			(4, 100),

5477

1

			(5, 100),

5478

1

			(6, 100),

5479

1

			(7, 100),

5480

1

			(8, 100),

5481

1

			(9, 100),

5482

1

			(10, 100),

5483

1

])

5484

1

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

5485

1

		.with_delegations(vec![

5486

1

			(6, 1, 10),

5487

1

			(7, 1, 10),

5488

1

			(8, 2, 10),

5489

1

			(9, 2, 10),

5490

1

			(10, 1, 10),

5491

1

])

5492

1

		.build()

5493

1

		.execute_with(|| {

5494

1

			roll_to_round_begin(2);

5495

1

			// chooses top TotalSelectedCandidates (5), in order

5496

1

			assert_events_eq!(

5497

1

				Event::CollatorChosen {

5498

1

					round: 2,

5499

1

					collator_account: 1,

5500

1

					total_exposed_amount: 50,

5501

1

},

5502

1

				Event::CollatorChosen {

5503

1

					round: 2,

5504

1

					collator_account: 2,

5505

1

					total_exposed_amount: 40,

5506

1

},

5507

1

				Event::CollatorChosen {

5508

1

					round: 2,

5509

1

					collator_account: 3,

5510

1

					total_exposed_amount: 20,

5511

1

},

5512

1

				Event::CollatorChosen {

5513

1

					round: 2,

5514

1

					collator_account: 4,

5515

1

					total_exposed_amount: 20,

5516

1

},

5517

1

				Event::CollatorChosen {

5518

1

					round: 2,

5519

1

					collator_account: 5,

5520

1

					total_exposed_amount: 10,

5521

1

},

5522

1

				Event::NewRound {

5523

1

					starting_block: 5,

5524

1

					round: 2,

5525

1

					selected_collators_number: 5,

5526

1

					total_balance: 140,

5527

1

},

5528

1

);

5529

1

			roll_blocks(1);

5530

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5531

1

				RuntimeOrigin::signed(6),

5532

1

2,

5533

1

10,

5534

1

				Percent::zero(),

5535

1

10,

5536

1

0,

5537

1

5538

1

));

5539

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5540

1

				RuntimeOrigin::signed(6),

5541

1

3,

5542

1

10,

5543

1

				Percent::zero(),

5544

1

10,

5545

1

0,

5546

1

5547

1

));

5548

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5549

1

				RuntimeOrigin::signed(6),

5550

1

4,

5551

1

10,

5552

1

				Percent::zero(),

5553

1

10,

5554

1

0,

5555

1

5556

1

));

5557

1

			assert_events_eq!(

5558

1

				Event::Delegation {

5559

1

					delegator: 6,

5560

1

					locked_amount: 10,

5561

1

					candidate: 2,

5562

1

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

5563

1

					auto_compound: Percent::zero(),

5564

1

},

5565

1

				Event::Delegation {

5566

1

					delegator: 6,

5567

1

					locked_amount: 10,

5568

1

					candidate: 3,

5569

1

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

5570

1

					auto_compound: Percent::zero(),

5571

1

},

5572

1

				Event::Delegation {

5573

1

					delegator: 6,

5574

1

					locked_amount: 10,

5575

1

					candidate: 4,

5576

1

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

5577

1

					auto_compound: Percent::zero(),

5578

1

},

5579

1

);

5580

1

			roll_to_round_begin(6);

5581

1

			roll_blocks(1);

5582

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5583

1

				RuntimeOrigin::signed(7),

5584

1

2,

5585

1

80,

5586

1

				Percent::zero(),

5587

1

10,

5588

1

0,

5589

1

5590

1

));

5591

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

5592

1

				RuntimeOrigin::signed(10),

5593

1

2,

5594

1

10,

5595

1

				Percent::zero(),

5596

1

10,

5597

1

0,

5598

1

5599

1

));

5600

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

5601

1

				RuntimeOrigin::signed(2),

5602

1

5603

1

));

5604

1

			assert_events_eq!(

5605

1

				Event::Delegation {

5606

1

					delegator: 7,

5607

1

					locked_amount: 80,

5608

1

					candidate: 2,

5609

1

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

5610

1

					auto_compound: Percent::zero(),

5611

1

},

5612

1

				Event::Delegation {

5613

1

					delegator: 10,

5614

1

					locked_amount: 10,

5615

1

					candidate: 2,

5616

1

					delegator_position: DelegatorAdded::AddedToBottom,

5617

1

					auto_compound: Percent::zero(),

5618

1

},

5619

1

				Event::CandidateScheduledExit {

5620

1

					exit_allowed_round: 6,

5621

1

					candidate: 2,

5622

1

					scheduled_exit: 8

5623

1

},

5624

1

);

5625

1

			roll_to_round_begin(7);

5626

1

			assert_events_eq!(

5627

1

				Event::CollatorChosen {

5628

1

					round: 7,

5629

1

					collator_account: 1,

5630

1

					total_exposed_amount: 50,

5631

1

},

5632

1

				Event::CollatorChosen {

5633

1

					round: 7,

5634

1

					collator_account: 3,

5635

1

					total_exposed_amount: 30,

5636

1

},

5637

1

				Event::CollatorChosen {

5638

1

					round: 7,

5639

1

					collator_account: 4,

5640

1

					total_exposed_amount: 30,

5641

1

},

5642

1

				Event::CollatorChosen {

5643

1

					round: 7,

5644

1

					collator_account: 5,

5645

1

					total_exposed_amount: 10,

5646

1

},

5647

1

				Event::NewRound {

5648

1

					starting_block: 30,

5649

1

					round: 7,

5650

1

					selected_collators_number: 4,

5651

1

					total_balance: 120,

5652

1

},

5653

1

);

5654

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

5655

1

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

5656

1

			assert_eq!(

5657

1

				ParachainStaking::delegator_state(7)

5658

1

					.unwrap()

5659

1

					.delegations

5660

1

.0

5661

1

					.len(),

5662

1

				2usize

5663

1

);

5664

1

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

5665

1

			assert_eq!(

5666

1

				ParachainStaking::delegator_state(6)

5667

1

					.unwrap()

5668

1

					.delegations

5669

1

.0

5670

1

					.len(),

5671

1

				4usize

5672

1

);

5673

1

			assert_eq!(Balances::locks(&6)[0].amount, 40);

5674

1

			assert_eq!(Balances::locks(&7)[0].amount, 90);

5675

1

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

5676

1

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

5677

1

			roll_to_round_begin(8);

5678

1

			roll_blocks(1);

5679

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

5680

1

				RuntimeOrigin::signed(2),

5681

1

2,

5682

1

5683

1

));

5684

1

			assert_events_eq!(Event::CandidateLeft {

5685

1

				ex_candidate: 2,

5686

1

				unlocked_amount: 140,

5687

1

				new_total_amt_locked: 120,

5688

1

});

5689

1

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

5690

1

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

5691

1

			assert_eq!(

5692

1

				ParachainStaking::delegator_state(7)

5693

1

					.unwrap()

5694

1

					.delegations

5695

1

.0

5696

1

					.len(),

5697

1

				1usize

5698

1

);

5699

1

			assert_eq!(

5700

1

				ParachainStaking::delegator_state(6)

5701

1

					.unwrap()

5702

1

					.delegations

5703

1

.0

5704

1

					.len(),

5705

1

				3usize

5706

1

);

5707

1

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

5708

1

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

5709

1

});

5710

1

5711

5712

#[test]

5713

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

5714

// revoke request after 2 exits

5715

1

fn execute_leave_candidate_removes_delegations() {

5716

1

	ExtBuilder::default()

5717

1

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

5718

1

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

5719

1

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

5720

1

		.build()

5721

1

		.execute_with(|| {

5722

1

			// Verifies the revocation request is initially empty

5723

1

			assert!(!ParachainStaking::delegation_scheduled_requests(&2)

5724

1

				.iter()

5725

1

				.any(|x| x.delegator == 3));

5726

5727

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

5728

1

				RuntimeOrigin::signed(2),

5729

1

5730

1

));

5731

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

5732

1

				RuntimeOrigin::signed(3),

5733

1

5734

1

));

5735

			// Verifies the revocation request is present

5736

1

			assert!(ParachainStaking::delegation_scheduled_requests(&2)

5737

1

				.iter()

5738

1

				.any(|x| x.delegator == 3));

5739

5740

1

			roll_to(16);

5741

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

5742

1

				RuntimeOrigin::signed(2),

5743

1

2,

5744

1

5745

1

));

5746

			// Verifies the revocation request is again empty

5747

1

			assert!(!ParachainStaking::delegation_scheduled_requests(&2)

5748

1

				.iter()

5749

1

				.any(|x| x.delegator == 3));

5750

1

});

5751

1

5752

5753

#[test]

5754

1

fn payouts_follow_delegation_changes() {

5755

1

	ExtBuilder::default()

5756

1

		.with_balances(vec![

5757

1

			(1, 100),

5758

1

			(2, 100),

5759

1

			(3, 100),

5760

1

			(4, 100),

5761

1

			(6, 100),

5762

1

			(7, 100),

5763

1

			(8, 100),

5764

1

			(9, 100),

5765

1

			(10, 100),

5766

1

])

5767

1

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

5768

1

		.with_delegations(vec![

5769

1

			(6, 1, 10),

5770

1

			(7, 1, 10),

5771

1

			(8, 2, 10),

5772

1

			(9, 2, 10),

5773

1

			(10, 1, 10),

5774

1

])

5775

1

		.build()

5776

1

		.execute_with(|| {

5777

1

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

5778

1

			set_author(1, 1, POINTS_PER_ROUND);

5779

1

			set_author(2, 1, POINTS_PER_ROUND);

5780

1

			roll_to_round_begin(2);

5781

1

			// chooses top TotalSelectedCandidates (5), in order

5782

1

			assert_events_eq!(

5783

1

				Event::CollatorChosen {

5784

1

					round: 2,

5785

1

					collator_account: 1,

5786

1

					total_exposed_amount: 50,

5787

1

},

5788

1

				Event::CollatorChosen {

5789

1

					round: 2,

5790

1

					collator_account: 2,

5791

1

					total_exposed_amount: 40,

5792

1

},

5793

1

				Event::CollatorChosen {

5794

1

					round: 2,

5795

1

					collator_account: 3,

5796

1

					total_exposed_amount: 20,

5797

1

},

5798

1

				Event::CollatorChosen {

5799

1

					round: 2,

5800

1

					collator_account: 4,

5801

1

					total_exposed_amount: 20,

5802

1

},

5803

1

				Event::NewRound {

5804

1

					starting_block: 5,

5805

1

					round: 2,

5806

1

					selected_collators_number: 4,

5807

1

					total_balance: 130,

5808

1

},

5809

1

);

5810

5811

1

			set_author(3, 1, POINTS_PER_ROUND);

5812

1

			set_author(4, 1, POINTS_PER_ROUND);

5813

1

5814

1

			roll_to_round_begin(4);

5815

1

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

5816

1

			assert_events_eq!(

5817

1

				Event::CollatorChosen {

5818

1

					round: 4,

5819

1

					collator_account: 1,

5820

1

					total_exposed_amount: 50,

5821

1

},

5822

1

				Event::CollatorChosen {

5823

1

					round: 4,

5824

1

					collator_account: 2,

5825

1

					total_exposed_amount: 40,

5826

1

},

5827

1

				Event::CollatorChosen {

5828

1

					round: 4,

5829

1

					collator_account: 3,

5830

1

					total_exposed_amount: 20,

5831

1

},

5832

1

				Event::CollatorChosen {

5833

1

					round: 4,

5834

1

					collator_account: 4,

5835

1

					total_exposed_amount: 20,

5836

1

},

5837

1

				Event::NewRound {

5838

1

					starting_block: 15,

5839

1

					round: 4,

5840

1

					selected_collators_number: 4,

5841

1

					total_balance: 130,

5842

1

},

5843

1

);

5844

1

			roll_blocks(3);

5845

1

			assert_events_eq!(

5846

1

				Event::Rewarded {

5847

1

					account: 1,

5848

1

					rewards: 11,

5849

1

},

5850

1

				Event::Rewarded {

5851

1

					account: 6,

5852

1

					rewards: 4,

5853

1

},

5854

1

				Event::Rewarded {

5855

1

					account: 7,

5856

1

					rewards: 4,

5857

1

},

5858

1

				Event::Rewarded {

5859

1

					account: 10,

5860

1

					rewards: 4,

5861

1

},

5862

1

);

5863

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

5864

1

			set_author(5, 1, POINTS_PER_ROUND);

5865

1

5866

1

			roll_blocks(1);

5867

1

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

5868

1

			assert_noop!(

5869

1

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

5870

1

				Error::<Test>::DelegatorDNE

5871

1

);

5872

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

5873

1

				RuntimeOrigin::signed(6),

5874

1

1,

5875

1

));

5876

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

5877

1

				round: 4,

5878

1

				delegator: 6,

5879

1

				candidate: 1,

5880

1

				scheduled_exit: 6,

5881

1

});

5882

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

5883

1

			roll_to_round_begin(5);

5884

1

			assert_events_eq!(

5885

1

				Event::CollatorChosen {

5886

1

					round: 5,

5887

1

					collator_account: 1,

5888

1

					total_exposed_amount: 50,

5889

1

},

5890

1

				Event::CollatorChosen {

5891

1

					round: 5,

5892

1

					collator_account: 2,

5893

1

					total_exposed_amount: 40,

5894

1

},

5895

1

				Event::CollatorChosen {

5896

1

					round: 5,

5897

1

					collator_account: 3,

5898

1

					total_exposed_amount: 20,

5899

1

},

5900

1

				Event::CollatorChosen {

5901

1

					round: 5,

5902

1

					collator_account: 4,

5903

1

					total_exposed_amount: 20,

5904

1

},

5905

1

				Event::NewRound {

5906

1

					starting_block: 20,

5907

1

					round: 5,

5908

1

					selected_collators_number: 4,

5909

1

					total_balance: 130,

5910

1

},

5911

1

);

5912

1

			roll_blocks(3);

5913

1

			assert_events_eq!(

5914

1

				Event::Rewarded {

5915

1

					account: 1,

5916

1

					rewards: 12,

5917

1

},

5918

1

				Event::Rewarded {

5919

1

					account: 6,

5920

1

					rewards: 4,

5921

1

},

5922

1

				Event::Rewarded {

5923

1

					account: 7,

5924

1

					rewards: 4,

5925

1

},

5926

1

				Event::Rewarded {

5927

1

					account: 10,

5928

1

					rewards: 4,

5929

1

},

5930

1

);

5931

5932

1

			set_author(6, 1, POINTS_PER_ROUND);

5933

1

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

5934

1

			roll_to_round_begin(6);

5935

1

			assert_ok!(ParachainStaking::execute_delegation_request(

5936

1

				RuntimeOrigin::signed(6),

5937

1

6,

5938

1

1,

5939

1

));

5940

1

			assert_events_eq!(

5941

1

				Event::CollatorChosen {

5942

1

					round: 6,

5943

1

					collator_account: 1,

5944

1

					total_exposed_amount: 50,

5945

1

},

5946

1

				Event::CollatorChosen {

5947

1

					round: 6,

5948

1

					collator_account: 2,

5949

1

					total_exposed_amount: 40,

5950

1

},

5951

1

				Event::CollatorChosen {

5952

1

					round: 6,

5953

1

					collator_account: 3,

5954

1

					total_exposed_amount: 20,

5955

1

},

5956

1

				Event::CollatorChosen {

5957

1

					round: 6,

5958

1

					collator_account: 4,

5959

1

					total_exposed_amount: 20,

5960

1

},

5961

1

				Event::NewRound {

5962

1

					starting_block: 25,

5963

1

					round: 6,

5964

1

					selected_collators_number: 4,

5965

1

					total_balance: 130,

5966

1

},

5967

1

				Event::DelegatorLeftCandidate {

5968

1

					delegator: 6,

5969

1

					candidate: 1,

5970

1

					unstaked_amount: 10,

5971

1

					total_candidate_staked: 40,

5972

1

},

5973

1

				Event::DelegationRevoked {

5974

1

					delegator: 6,

5975

1

					candidate: 1,

5976

1

					unstaked_amount: 10,

5977

1

},

5978

1

				Event::DelegatorLeft {

5979

1

					delegator: 6,

5980

1

					unstaked_amount: 10,

5981

1

},

5982

1

);

5983

1

			roll_blocks(3);

5984

1

			assert_events_eq!(

5985

1

				Event::Rewarded {

5986

1

					account: 1,

5987

1

					rewards: 12,

5988

1

},

5989

1

				Event::Rewarded {

5990

1

					account: 6,

5991

1

					rewards: 4,

5992

1

},

5993

1

				Event::Rewarded {

5994

1

					account: 7,

5995

1

					rewards: 4,

5996

1

},

5997

1

				Event::Rewarded {

5998

1

					account: 10,

5999

1

					rewards: 4,

6000

1

},

6001

1

);

6002

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

6003

1

			set_author(7, 1, POINTS_PER_ROUND);

6004

1

			roll_to_round_begin(7);

6005

1

			// keep paying 6

6006

1

			assert_events_eq!(

6007

1

				Event::CollatorChosen {

6008

1

					round: 7,

6009

1

					collator_account: 1,

6010

1

					total_exposed_amount: 40,

6011

1

},

6012

1

				Event::CollatorChosen {

6013

1

					round: 7,

6014

1

					collator_account: 2,

6015

1

					total_exposed_amount: 40,

6016

1

},

6017

1

				Event::CollatorChosen {

6018

1

					round: 7,

6019

1

					collator_account: 3,

6020

1

					total_exposed_amount: 20,

6021

1

},

6022

1

				Event::CollatorChosen {

6023

1

					round: 7,

6024

1

					collator_account: 4,

6025

1

					total_exposed_amount: 20,

6026

1

},

6027

1

				Event::NewRound {

6028

1

					starting_block: 30,

6029

1

					round: 7,

6030

1

					selected_collators_number: 4,

6031

1

					total_balance: 120,

6032

1

},

6033

1

);

6034

1

			roll_blocks(3);

6035

1

			assert_events_eq!(

6036

1

				Event::Rewarded {

6037

1

					account: 1,

6038

1

					rewards: 14,

6039

1

},

6040

1

				Event::Rewarded {

6041

1

					account: 7,

6042

1

					rewards: 5,

6043

1

},

6044

1

				Event::Rewarded {

6045

1

					account: 10,

6046

1

					rewards: 5,

6047

1

},

6048

1

);

6049

1

			set_author(8, 1, POINTS_PER_ROUND);

6050

1

			roll_to_round_begin(8);

6051

1

			assert_events_eq!(

6052

1

				Event::CollatorChosen {

6053

1

					round: 8,

6054

1

					collator_account: 1,

6055

1

					total_exposed_amount: 40,

6056

1

},

6057

1

				Event::CollatorChosen {

6058

1

					round: 8,

6059

1

					collator_account: 2,

6060

1

					total_exposed_amount: 40,

6061

1

},

6062

1

				Event::CollatorChosen {

6063

1

					round: 8,

6064

1

					collator_account: 3,

6065

1

					total_exposed_amount: 20,

6066

1

},

6067

1

				Event::CollatorChosen {

6068

1

					round: 8,

6069

1

					collator_account: 4,

6070

1

					total_exposed_amount: 20,

6071

1

},

6072

1

				Event::NewRound {

6073

1

					starting_block: 35,

6074

1

					round: 8,

6075

1

					selected_collators_number: 4,

6076

1

					total_balance: 120,

6077

1

},

6078

1

);

6079

1

			roll_blocks(3);

6080

1

			assert_events_eq!(

6081

1

				Event::Rewarded {

6082

1

					account: 1,

6083

1

					rewards: 15,

6084

1

},

6085

1

				Event::Rewarded {

6086

1

					account: 7,

6087

1

					rewards: 5,

6088

1

},

6089

1

				Event::Rewarded {

6090

1

					account: 10,

6091

1

					rewards: 5,

6092

1

},

6093

1

);

6094

1

			set_author(9, 1, POINTS_PER_ROUND);

6095

1

			roll_to_round_begin(9);

6096

1

			// no more paying 6

6097

1

			assert_events_eq!(

6098

1

				Event::CollatorChosen {

6099

1

					round: 9,

6100

1

					collator_account: 1,

6101

1

					total_exposed_amount: 40,

6102

1

},

6103

1

				Event::CollatorChosen {

6104

1

					round: 9,

6105

1

					collator_account: 2,

6106

1

					total_exposed_amount: 40,

6107

1

},

6108

1

				Event::CollatorChosen {

6109

1

					round: 9,

6110

1

					collator_account: 3,

6111

1

					total_exposed_amount: 20,

6112

1

},

6113

1

				Event::CollatorChosen {

6114

1

					round: 9,

6115

1

					collator_account: 4,

6116

1

					total_exposed_amount: 20,

6117

1

},

6118

1

				Event::NewRound {

6119

1

					starting_block: 40,

6120

1

					round: 9,

6121

1

					selected_collators_number: 4,

6122

1

					total_balance: 120,

6123

1

},

6124

1

);

6125

1

			roll_blocks(3);

6126

1

			assert_events_eq!(

6127

1

				Event::Rewarded {

6128

1

					account: 1,

6129

1

					rewards: 15,

6130

1

},

6131

1

				Event::Rewarded {

6132

1

					account: 7,

6133

1

					rewards: 5,

6134

1

},

6135

1

				Event::Rewarded {

6136

1

					account: 10,

6137

1

					rewards: 5,

6138

1

},

6139

1

);

6140

1

			roll_blocks(1);

6141

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

6142

1

				RuntimeOrigin::signed(8),

6143

1

1,

6144

1

10,

6145

1

				Percent::zero(),

6146

1

10,

6147

1

0,

6148

1

6149

1

));

6150

1

			assert_events_eq!(Event::Delegation {

6151

1

				delegator: 8,

6152

1

				locked_amount: 10,

6153

1

				candidate: 1,

6154

1

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

6155

1

				auto_compound: Percent::zero(),

6156

1

});

6157

6158

1

			set_author(10, 1, POINTS_PER_ROUND);

6159

1

			roll_to_round_begin(10);

6160

1

			// new delegation is not rewarded yet

6161

1

			assert_events_eq!(

6162

1

				Event::CollatorChosen {

6163

1

					round: 10,

6164

1

					collator_account: 1,

6165

1

					total_exposed_amount: 50,

6166

1

},

6167

1

				Event::CollatorChosen {

6168

1

					round: 10,

6169

1

					collator_account: 2,

6170

1

					total_exposed_amount: 40,

6171

1

},

6172

1

				Event::CollatorChosen {

6173

1

					round: 10,

6174

1

					collator_account: 3,

6175

1

					total_exposed_amount: 20,

6176

1

},

6177

1

				Event::CollatorChosen {

6178

1

					round: 10,

6179

1

					collator_account: 4,

6180

1

					total_exposed_amount: 20,

6181

1

},

6182

1

				Event::NewRound {

6183

1

					starting_block: 45,

6184

1

					round: 10,

6185

1

					selected_collators_number: 4,

6186

1

					total_balance: 130,

6187

1

},

6188

1

);

6189

1

			roll_blocks(3);

6190

1

			assert_events_eq!(

6191

1

				Event::Rewarded {

6192

1

					account: 1,

6193

1

					rewards: 15,

6194

1

},

6195

1

				Event::Rewarded {

6196

1

					account: 7,

6197

1

					rewards: 5,

6198

1

},

6199

1

				Event::Rewarded {

6200

1

					account: 10,

6201

1

					rewards: 5,

6202

1

},

6203

1

);

6204

1

			roll_to_round_begin(11);

6205

1

			// new delegation not rewarded yet

6206

1

			assert_events_eq!(

6207

1

				Event::CollatorChosen {

6208

1

					round: 11,

6209

1

					collator_account: 1,

6210

1

					total_exposed_amount: 50,

6211

1

},

6212

1

				Event::CollatorChosen {

6213

1

					round: 11,

6214

1

					collator_account: 2,

6215

1

					total_exposed_amount: 40,

6216

1

},

6217

1

				Event::CollatorChosen {

6218

1

					round: 11,

6219

1

					collator_account: 3,

6220

1

					total_exposed_amount: 20,

6221

1

},

6222

1

				Event::CollatorChosen {

6223

1

					round: 11,

6224

1

					collator_account: 4,

6225

1

					total_exposed_amount: 20,

6226

1

},

6227

1

				Event::NewRound {

6228

1

					starting_block: 50,

6229

1

					round: 11,

6230

1

					selected_collators_number: 4,

6231

1

					total_balance: 130,

6232

1

},

6233

1

);

6234

1

			roll_blocks(3);

6235

1

			assert_events_eq!(

6236

1

				Event::Rewarded {

6237

1

					account: 1,

6238

1

					rewards: 15,

6239

1

},

6240

1

				Event::Rewarded {

6241

1

					account: 7,

6242

1

					rewards: 5,

6243

1

},

6244

1

				Event::Rewarded {

6245

1

					account: 10,

6246

1

					rewards: 5,

6247

1

},

6248

1

);

6249

1

			roll_to_round_begin(12);

6250

1

			// new delegation is rewarded for first time

6251

1

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

6252

1

			assert_events_eq!(

6253

1

				Event::CollatorChosen {

6254

1

					round: 12,

6255

1

					collator_account: 1,

6256

1

					total_exposed_amount: 50,

6257

1

},

6258

1

				Event::CollatorChosen {

6259

1

					round: 12,

6260

1

					collator_account: 2,

6261

1

					total_exposed_amount: 40,

6262

1

},

6263

1

				Event::CollatorChosen {

6264

1

					round: 12,

6265

1

					collator_account: 3,

6266

1

					total_exposed_amount: 20,

6267

1

},

6268

1

				Event::CollatorChosen {

6269

1

					round: 12,

6270

1

					collator_account: 4,

6271

1

					total_exposed_amount: 20,

6272

1

},

6273

1

				Event::NewRound {

6274

1

					starting_block: 55,

6275

1

					round: 12,

6276

1

					selected_collators_number: 4,

6277

1

					total_balance: 130,

6278

1

},

6279

1

);

6280

1

			roll_blocks(3);

6281

1

			assert_events_eq!(

6282

1

				Event::Rewarded {

6283

1

					account: 1,

6284

1

					rewards: 14,

6285

1

},

6286

1

				Event::Rewarded {

6287

1

					account: 7,

6288

1

					rewards: 4,

6289

1

},

6290

1

				Event::Rewarded {

6291

1

					account: 10,

6292

1

					rewards: 4,

6293

1

},

6294

1

				Event::Rewarded {

6295

1

					account: 8,

6296

1

					rewards: 4,

6297

1

},

6298

1

);

6299

1

});

6300

1

6301

6302

#[test]

6303

1

fn bottom_delegations_are_empty_when_top_delegations_not_full() {

6304

1

	ExtBuilder::default()

6305

1

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

6306

1

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

6307

1

		.build()

6308

1

		.execute_with(|| {

6309

1

			// no top delegators => no bottom delegators

6310

1

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

6311

1

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

6312

1

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

6313

1

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

6314

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

6315

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

6316

1

				RuntimeOrigin::signed(2),

6317

1

1,

6318

1

10,

6319

1

				Percent::zero(),

6320

1

10,

6321

1

0,

6322

1

6323

1

));

6324

1

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

6325

1

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

6326

1

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

6327

1

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

6328

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

6329

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

6330

1

				RuntimeOrigin::signed(3),

6331

1

1,

6332

1

10,

6333

1

				Percent::zero(),

6334

1

10,

6335

1

0,

6336

1

6337

1

));

6338

1

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

6339

1

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

6340

1

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

6341

1

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

6342

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

6343

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

6344

1

				RuntimeOrigin::signed(4),

6345

1

1,

6346

1

10,

6347

1

				Percent::zero(),

6348

1

10,

6349

1

0,

6350

1

6351

1

));

6352

1

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

6353

1

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

6354

1

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

6355

1

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

6356

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

6357

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

6358

1

				RuntimeOrigin::signed(5),

6359

1

1,

6360

1

10,

6361

1

				Percent::zero(),

6362

1

10,

6363

1

0,

6364

1

6365

1

));

6366

1

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

6367

1

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

6368

1

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

6369

1

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

6370

1

});

6371

1

6372

6373

#[test]

6374

1

fn candidate_pool_updates_when_total_counted_changes() {

6375

1

	ExtBuilder::default()

6376

1

		.with_balances(vec![

6377

1

			(1, 20),

6378

1

			(3, 19),

6379

1

			(4, 20),

6380

1

			(5, 21),

6381

1

			(6, 22),

6382

1

			(7, 15),

6383

1

			(8, 16),

6384

1

			(9, 17),

6385

1

			(10, 18),

6386

1

])

6387

1

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

6388

1

		.with_delegations(vec![

6389

1

			(3, 1, 11),

6390

1

			(4, 1, 12),

6391

1

			(5, 1, 13),

6392

1

			(6, 1, 14),

6393

1

			(7, 1, 15),

6394

1

			(8, 1, 16),

6395

1

			(9, 1, 17),

6396

1

			(10, 1, 18),

6397

1

])

6398

1

		.build()

6399

1

		.execute_with(|| {

6400

5

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

6401

5

				let pool = ParachainStaking::candidate_pool();

6402

10

				for candidate in pool.0 {

6403

5

					if candidate.owner == account {

6404

5

						assert_eq!(

6405

							candidate.amount, bond,

6406

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

6407

							candidate.amount, bond

6408

);

6409

6410

6411

5

6412

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

6413

1

			is_candidate_pool_bond(1, 86);

6414

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6415

1

				RuntimeOrigin::signed(3),

6416

1

1,

6417

1

6418

1

));

6419

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

6420

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

6421

1

			is_candidate_pool_bond(1, 90);

6422

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6423

1

				RuntimeOrigin::signed(4),

6424

1

1,

6425

1

6426

1

));

6427

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

6428

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

6429

1

			is_candidate_pool_bond(1, 94);

6430

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

6431

1

				RuntimeOrigin::signed(10),

6432

1

1,

6433

1

6434

1

));

6435

1

			roll_to(30);

6436

1

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

6437

1

			assert_ok!(ParachainStaking::execute_delegation_request(

6438

1

				RuntimeOrigin::signed(10),

6439

1

10,

6440

1

6441

1

));

6442

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

6443

1

			is_candidate_pool_bond(1, 92);

6444

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

6445

1

				RuntimeOrigin::signed(9),

6446

1

1,

6447

1

6448

1

));

6449

1

			roll_to(40);

6450

1

			assert_ok!(ParachainStaking::execute_delegation_request(

6451

1

				RuntimeOrigin::signed(9),

6452

1

9,

6453

1

6454

1

));

6455

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

6456

1

			is_candidate_pool_bond(1, 90);

6457

1

});

6458

1

6459

6460

#[test]

6461

1

fn only_top_collators_are_counted() {

6462

1

	ExtBuilder::default()

6463

1

		.with_balances(vec![

6464

1

			(1, 20),

6465

1

			(3, 19),

6466

1

			(4, 20),

6467

1

			(5, 21),

6468

1

			(6, 22),

6469

1

			(7, 15),

6470

1

			(8, 16),

6471

1

			(9, 17),

6472

1

			(10, 18),

6473

1

])

6474

1

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

6475

1

		.with_delegations(vec![

6476

1

			(3, 1, 11),

6477

1

			(4, 1, 12),

6478

1

			(5, 1, 13),

6479

1

			(6, 1, 14),

6480

1

			(7, 1, 15),

6481

1

			(8, 1, 16),

6482

1

			(9, 1, 17),

6483

1

			(10, 1, 18),

6484

1

])

6485

1

		.build()

6486

1

		.execute_with(|| {

6487

			// sanity check that 3-10 are delegators immediately

6488

9

			for i in 3..11 {

6489

8

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

6490

6491

1

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

6492

1

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

6493

1

			assert_eq!(collator_state.total_counted, 86);

6494

			// bump bottom to the top

6495

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6496

1

				RuntimeOrigin::signed(3),

6497

1

1,

6498

1

6499

1

));

6500

1

			assert_events_emitted!(Event::DelegationIncreased {

6501

1

				delegator: 3,

6502

1

				candidate: 1,

6503

1

				amount: 8,

6504

1

				in_top: true,

6505

1

});

6506

1

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

6507

1

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

6508

1

			assert_eq!(collator_state.total_counted, 90);

6509

			// bump bottom to the top

6510

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6511

1

				RuntimeOrigin::signed(4),

6512

1

1,

6513

1

6514

1

));

6515

1

			assert_events_emitted!(Event::DelegationIncreased {

6516

1

				delegator: 4,

6517

1

				candidate: 1,

6518

1

				amount: 8,

6519

1

				in_top: true,

6520

1

});

6521

1

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

6522

1

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

6523

1

			assert_eq!(collator_state.total_counted, 94);

6524

			// bump bottom to the top

6525

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6526

1

				RuntimeOrigin::signed(5),

6527

1

1,

6528

1

6529

1

));

6530

1

			assert_events_emitted!(Event::DelegationIncreased {

6531

1

				delegator: 5,

6532

1

				candidate: 1,

6533

1

				amount: 8,

6534

1

				in_top: true,

6535

1

});

6536

1

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

6537

1

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

6538

1

			assert_eq!(collator_state.total_counted, 98);

6539

			// bump bottom to the top

6540

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6541

1

				RuntimeOrigin::signed(6),

6542

1

1,

6543

1

6544

1

));

6545

1

			assert_events_emitted!(Event::DelegationIncreased {

6546

1

				delegator: 6,

6547

1

				candidate: 1,

6548

1

				amount: 8,

6549

1

				in_top: true,

6550

1

});

6551

1

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

6552

1

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

6553

1

			assert_eq!(collator_state.total_counted, 102);

6554

1

});

6555

1

6556

6557

#[test]

6558

1

fn delegation_events_convey_correct_position() {

6559

1

	ExtBuilder::default()

6560

1

		.with_balances(vec![

6561

1

			(1, 100),

6562

1

			(2, 100),

6563

1

			(3, 100),

6564

1

			(4, 100),

6565

1

			(5, 100),

6566

1

			(6, 100),

6567

1

			(7, 100),

6568

1

			(8, 100),

6569

1

			(9, 100),

6570

1

			(10, 100),

6571

1

])

6572

1

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

6573

1

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

6574

1

		.build()

6575

1

		.execute_with(|| {

6576

1

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

6577

1

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

6578

1

			assert_eq!(collator1_state.total_counted, 70);

6579

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

6580

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

6581

1

				RuntimeOrigin::signed(7),

6582

1

1,

6583

1

15,

6584

1

				Percent::zero(),

6585

1

10,

6586

1

0,

6587

1

6588

1

));

6589

1

			assert_events_emitted!(Event::Delegation {

6590

1

				delegator: 7,

6591

1

				locked_amount: 15,

6592

1

				candidate: 1,

6593

1

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

6594

1

				auto_compound: Percent::zero(),

6595

1

});

6596

1

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

6597

1

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

6598

1

			assert_eq!(collator1_state.total_counted, 74);

6599

			// New delegation is added to the bottom

6600

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

6601

1

				RuntimeOrigin::signed(8),

6602

1

1,

6603

1

10,

6604

1

				Percent::zero(),

6605

1

10,

6606

1

0,

6607

1

6608

1

));

6609

1

			assert_events_emitted!(Event::Delegation {

6610

1

				delegator: 8,

6611

1

				locked_amount: 10,

6612

1

				candidate: 1,

6613

1

				delegator_position: DelegatorAdded::AddedToBottom,

6614

1

				auto_compound: Percent::zero(),

6615

1

});

6616

1

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

6617

1

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

6618

1

			assert_eq!(collator1_state.total_counted, 74);

6619

			// 8 increases delegation to the top

6620

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6621

1

				RuntimeOrigin::signed(8),

6622

1

1,

6623

1

6624

1

));

6625

1

			assert_events_emitted!(Event::DelegationIncreased {

6626

1

				delegator: 8,

6627

1

				candidate: 1,

6628

1

				amount: 3,

6629

1

				in_top: true,

6630

1

});

6631

1

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

6632

1

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

6633

1

			assert_eq!(collator1_state.total_counted, 75);

6634

			// 3 increases delegation but stays in bottom

6635

1

			assert_ok!(ParachainStaking::delegator_bond_more(

6636

1

				RuntimeOrigin::signed(3),

6637

1

1,

6638

1

6639

1

));

6640

1

			assert_events_emitted!(Event::DelegationIncreased {

6641

1

				delegator: 3,

6642

1

				candidate: 1,

6643

1

				amount: 1,

6644

1

				in_top: false,

6645

1

});

6646

1

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

6647

1

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

6648

1

			assert_eq!(collator1_state.total_counted, 75);

6649

			// 6 decreases delegation but stays in top

6650

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

6651

1

				RuntimeOrigin::signed(6),

6652

1

1,

6653

1

6654

1

));

6655

1

			assert_events_emitted!(Event::DelegationDecreaseScheduled {

6656

1

				delegator: 6,

6657

1

				candidate: 1,

6658

1

				amount_to_decrease: 2,

6659

1

				execute_round: 3,

6660

1

});

6661

1

			roll_to(30);

6662

1

			assert_ok!(ParachainStaking::execute_delegation_request(

6663

1

				RuntimeOrigin::signed(6),

6664

1

6,

6665

1

6666

1

));

6667

1

			assert_events_emitted!(Event::DelegationDecreased {

6668

1

				delegator: 6,

6669

1

				candidate: 1,

6670

1

				amount: 2,

6671

1

				in_top: true,

6672

1

});

6673

1

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

6674

1

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

6675

1

			assert_eq!(collator1_state.total_counted, 73);

6676

			// 6 decreases delegation and is bumped to bottom

6677

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

6678

1

				RuntimeOrigin::signed(6),

6679

1

1,

6680

1

6681

1

));

6682

1

			assert_events_emitted!(Event::DelegationDecreaseScheduled {

6683

1

				delegator: 6,

6684

1

				candidate: 1,

6685

1

				amount_to_decrease: 1,

6686

1

				execute_round: 9,

6687

1

});

6688

1

			roll_to(40);

6689

1

			assert_ok!(ParachainStaking::execute_delegation_request(

6690

1

				RuntimeOrigin::signed(6),

6691

1

6,

6692

1

6693

1

));

6694

1

			assert_events_emitted!(Event::DelegationDecreased {

6695

1

				delegator: 6,

6696

1

				candidate: 1,

6697

1

				amount: 1,

6698

1

				in_top: false,

6699

1

});

6700

1

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

6701

1

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

6702

1

			assert_eq!(collator1_state.total_counted, 73);

6703

1

});

6704

1

6705

6706

#[test]

6707

1

fn no_rewards_paid_until_after_reward_payment_delay() {

6708

1

	ExtBuilder::default()

6709

1

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

6710

1

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

6711

1

		.build()

6712

1

		.execute_with(|| {

6713

1

			// payouts for round 1

6714

1

			set_author(1, 1, POINTS_PER_BLOCK);

6715

1

			set_author(1, 2, POINTS_PER_BLOCK * 2);

6716

1

			set_author(1, 3, POINTS_PER_BLOCK * 2);

6717

1

6718

1

			roll_to_round_begin(2);

6719

1

			assert_events_eq!(

6720

1

				Event::CollatorChosen {

6721

1

					round: 2,

6722

1

					collator_account: 1,

6723

1

					total_exposed_amount: 20,

6724

1

},

6725

1

				Event::CollatorChosen {

6726

1

					round: 2,

6727

1

					collator_account: 2,

6728

1

					total_exposed_amount: 20,

6729

1

},

6730

1

				Event::CollatorChosen {

6731

1

					round: 2,

6732

1

					collator_account: 3,

6733

1

					total_exposed_amount: 20,

6734

1

},

6735

1

				Event::NewRound {

6736

1

					starting_block: 5,

6737

1

					round: 2,

6738

1

					selected_collators_number: 3,

6739

1

					total_balance: 60,

6740

1

},

6741

1

);

6742

6743

1

			roll_to_round_begin(3);

6744

1

			assert_events_eq!(

6745

1

				Event::CollatorChosen {

6746

1

					round: 3,

6747

1

					collator_account: 1,

6748

1

					total_exposed_amount: 20,

6749

1

},

6750

1

				Event::CollatorChosen {

6751

1

					round: 3,

6752

1

					collator_account: 2,

6753

1

					total_exposed_amount: 20,

6754

1

},

6755

1

				Event::CollatorChosen {

6756

1

					round: 3,

6757

1

					collator_account: 3,

6758

1

					total_exposed_amount: 20,

6759

1

},

6760

1

				Event::NewRound {

6761

1

					starting_block: 10,

6762

1

					round: 3,

6763

1

					selected_collators_number: 3,

6764

1

					total_balance: 60,

6765

1

},

6766

1

);

6767

6768

1

			roll_blocks(1);

6769

1

			assert_events_eq!(Event::Rewarded {

6770

1

				account: 3,

6771

1

				rewards: 1,

6772

1

});

6773

6774

1

			roll_blocks(1);

6775

1

			assert_events_eq!(Event::Rewarded {

6776

1

				account: 1,

6777

1

				rewards: 0,

6778

1

});

6779

6780

1

			roll_blocks(1);

6781

1

			assert_events_eq!(Event::Rewarded {

6782

1

				account: 2,

6783

1

				rewards: 1,

6784

1

});

6785

6786

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

6787

1

			let num_blocks_rolled = roll_to_round_end(3);

6788

1

			assert_no_events!();

6789

1

			assert_eq!(num_blocks_rolled, 1);

6790

1

});

6791

1

6792

6793

#[test]

6794

1

fn deferred_payment_storage_items_are_cleaned_up() {

6795

	use crate::*;

6796

6797

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

6798

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

6799

6800

1

	ExtBuilder::default()

6801

1

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

6802

1

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

6803

1

		.build()

6804

1

		.execute_with(|| {

6805

1

			set_author(1, 1, POINTS_PER_BLOCK * 3);

6806

1

			set_author(1, 2, POINTS_PER_BLOCK * 2);

6807

1

6808

1

			// reflects genesis?

6809

1

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

6810

1

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

6811

6812

1

			roll_to_round_begin(2);

6813

1

			assert_events_eq!(

6814

1

				Event::CollatorChosen {

6815

1

					round: 2,

6816

1

					collator_account: 1,

6817

1

					total_exposed_amount: 20,

6818

1

},

6819

1

				Event::CollatorChosen {

6820

1

					round: 2,

6821

1

					collator_account: 2,

6822

1

					total_exposed_amount: 20,

6823

1

},

6824

1

				Event::NewRound {

6825

1

					starting_block: 5,

6826

1

					round: 2,

6827

1

					selected_collators_number: 2,

6828

1

					total_balance: 40,

6829

1

},

6830

1

);

6831

6832

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

6833

1

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

6834

1

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

6835

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

6836

1

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

6837

1

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

6838

6839

1

			assert!(

6840

1

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

6841

				"Points should be populated during current round"

6842

);

6843

6844

1

			assert!(

6845

1

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

6846

				"Points should not be populated until author noted"

6847

);

6848

6849

			// first payout occurs in round 3

6850

1

			roll_to_round_begin(3);

6851

1

			assert_events_eq!(

6852

1

				Event::CollatorChosen {

6853

1

					round: 3,

6854

1

					collator_account: 1,

6855

1

					total_exposed_amount: 20,

6856

1

},

6857

1

				Event::CollatorChosen {

6858

1

					round: 3,

6859

1

					collator_account: 2,

6860

1

					total_exposed_amount: 20,

6861

1

},

6862

1

				Event::NewRound {

6863

1

					starting_block: 10,

6864

1

					round: 3,

6865

1

					selected_collators_number: 2,

6866

1

					total_balance: 40,

6867

1

},

6868

1

);

6869

6870

1

			roll_blocks(1);

6871

1

			assert_events_eq!(Event::Rewarded {

6872

1

				account: 1,

6873

1

				rewards: 1,

6874

1

			},);

6875

6876

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

6877

1

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

6878

1

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

6879

1

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

6880

1

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

6881

6882

1

			assert!(

6883

1

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

6884

				"DelayedPayouts should be populated after RewardPaymentDelay"

6885

);

6886

1

			assert!(<Points<Test>>::contains_key(1));

6887

1

			assert!(<DelayedPayouts<Test>>::contains_key(2));

6888

1

			assert!(

6889

1

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

6890

				"We awarded points for round 2"

6891

);

6892

6893

1

			assert!(!<DelayedPayouts<Test>>::contains_key(3));

6894

1

			assert!(

6895

1

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

6896

				"We awarded points for round 3"

6897

);

6898

6899

			// collator 1 has been paid in this last block and associated storage cleaned up

6900

1

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

6901

1

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

6902

6903

			// but collator 2 hasn't been paid

6904

1

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

6905

1

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

6906

6907

			// second payout occurs in next block

6908

1

			roll_blocks(1);

6909

1

			assert_events_eq!(Event::Rewarded {

6910

1

				account: 2,

6911

1

				rewards: 0,

6912

1

			},);

6913

6914

1

			roll_to_round_begin(4);

6915

1

			assert_events_eq!(

6916

1

				Event::CollatorChosen {

6917

1

					round: 4,

6918

1

					collator_account: 1,

6919

1

					total_exposed_amount: 20,

6920

1

},

6921

1

				Event::CollatorChosen {

6922

1

					round: 4,

6923

1

					collator_account: 2,

6924

1

					total_exposed_amount: 20,

6925

1

},

6926

1

				Event::NewRound {

6927

1

					starting_block: 15,

6928

1

					round: 4,

6929

1

					selected_collators_number: 2,

6930

1

					total_balance: 40,

6931

1

},

6932

1

);

6933

6934

			// collators have both been paid and storage fully cleaned up for round 1

6935

1

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

6936

1

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

6937

1

			assert!(!<Points<Test>>::contains_key(1)); // points should be cleaned up

6938

1

			assert!(!<DelayedPayouts<Test>>::contains_key(1));

6939

6940

1

			roll_to_round_end(4);

6941

1

6942

1

			// no more events expected

6943

1

			assert_no_events!();

6944

1

});

6945

1

6946

6947

#[test]

6948

1

fn deferred_payment_and_at_stake_storage_items_cleaned_up_for_candidates_not_producing_blocks() {

6949

	use crate::*;

6950

6951

1

	ExtBuilder::default()

6952

1

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

6953

1

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

6954

1

		.build()

6955

1

		.execute_with(|| {

6956

1

			// candidate 3 will not produce blocks

6957

1

			set_author(1, 1, POINTS_PER_BLOCK * 3);

6958

1

			set_author(1, 2, POINTS_PER_BLOCK * 2);

6959

1

6960

1

			// reflects genesis?

6961

1

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

6962

1

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

6963

6964

1

			roll_to_round_begin(2);

6965

1

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

6966

1

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

6967

1

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

6968

1

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

6969

1

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

6970

1

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

6971

1

			assert!(<Points<Test>>::contains_key(1));

6972

1

			roll_to_round_begin(3);

6973

1

			assert!(<DelayedPayouts<Test>>::contains_key(1));

6974

6975

			// all storage items must be cleaned up

6976

1

			roll_to_round_begin(4);

6977

1

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

6978

1

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

6979

1

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

6980

1

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

6981

1

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

6982

1

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

6983

1

			assert!(!<Points<Test>>::contains_key(1));

6984

1

			assert!(!<DelayedPayouts<Test>>::contains_key(1));

6985

1

});

6986

1

6987

6988

#[test]

6989

1

fn deferred_payment_steady_state_event_flow() {

6990

	// this test "flows" through a number of rounds, asserting that certain things do/don't happen

6991

	// once the staking pallet is in a "steady state" (specifically, once we are past the first few

6992

	// rounds to clear RewardPaymentDelay)

6993

	use crate::mock::System;

6994

6995

1

	ExtBuilder::default()

6996

1

		.with_balances(vec![

6997

1

			// collators

6998

1

			(1, 200),

6999

1

			(2, 200),

7000

1

			(3, 200),

7001

1

			(4, 200),

7002

1

			// delegators

7003

1

			(11, 200),

7004

1

			(22, 200),

7005

1

			(33, 200),

7006

1

			(44, 200),

7007

1

			// burn account, see `reset_issuance()`

7008

1

			(111, 1000),

7009

1

])

7010

1

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

7011

1

		.with_delegations(vec![

7012

1

			// delegator 11 delegates 100 to 1 and 2

7013

1

			(11, 1, 100),

7014

1

			(11, 2, 100),

7015

1

			// delegator 22 delegates 100 to 2 and 3

7016

1

			(22, 2, 100),

7017

1

			(22, 3, 100),

7018

1

			// delegator 33 delegates 100 to 3 and 4

7019

1

			(33, 3, 100),

7020

1

			(33, 4, 100),

7021

1

			// delegator 44 delegates 100 to 4 and 1

7022

1

			(44, 4, 100),

7023

1

			(44, 1, 100),

7024

1

])

7025

1

		.build()

7026

1

		.execute_with(|| {

7027

1

			// convenience to set the round points consistently

7028

3

			let set_round_points = |round: BlockNumber| {

7029

3

				set_author(round as BlockNumber, 1, 2 * POINTS_PER_ROUND);

7030

3

				set_author(round as BlockNumber, 2, POINTS_PER_ROUND);

7031

3

				set_author(round as BlockNumber, 3, POINTS_PER_ROUND);

7032

3

				set_author(round as BlockNumber, 4, POINTS_PER_ROUND);

7033

3

};

7034

7035

			// grab initial issuance -- we will reset it before round issuance is calculated so that

7036

			// it is consistent every round

7037

1

			let account: AccountId = 111;

7038

1

			let initial_issuance = Balances::total_issuance();

7039

2

			let reset_issuance = || {

7040

2

				let new_issuance = Balances::total_issuance();

7041

2

				let amount_to_burn = new_issuance - initial_issuance;

7042

2

				let _ = Balances::burn(Some(account).into(), amount_to_burn, false);

7043

2

				System::assert_last_event(RuntimeEvent::Balances(BalancesEvent::Burned {

7044

2

					who: account,

7045

2

					amount: amount_to_burn,

7046

2

				}));

7047

2

				Balances::settle(

7048

2

					&account,

7049

2

					PositiveImbalance::new(amount_to_burn),

7050

2

					WithdrawReasons::FEE,

7051

2

					ExistenceRequirement::AllowDeath,

7052

2

7053

2

				.expect("Account can absorb burn");

7054

2

};

7055

7056

			// fn to roll through the first RewardPaymentDelay rounds. returns new round index

7057

1

			let roll_through_initial_rounds = |mut round: BlockNumber| -> BlockNumber {

7058

3

				while round < crate::mock::RewardPaymentDelay::get() + 1 {

7059

2

					set_round_points(round);

7060

2

7061

2

					roll_to_round_end(round);

7062

2

					round += 1;

7063

2

7064

1

				reset_issuance();

7065

1

7066

1

				round

7067

1

};

7068

7069

			// roll through a "steady state" round and make all of our assertions

7070

			// returns new round index

7071

1

			let roll_through_steady_state_round = |round: BlockNumber| -> BlockNumber {

7072

1

				let num_rounds_rolled = roll_to_round_begin(round);

7073

1

				assert!(

7074

1

					num_rounds_rolled <= 1,

7075

					"expected to be at round begin already"

7076

);

7077

7078

1

				assert_events_eq!(

7079

1

					Event::CollatorChosen {

7080

1

						round: round as u32,

7081

1

						collator_account: 1,

7082

1

						total_exposed_amount: 400,

7083

1

},

7084

1

					Event::CollatorChosen {

7085

1

						round: round as u32,

7086

1

						collator_account: 2,

7087

1

						total_exposed_amount: 400,

7088

1

},

7089

1

					Event::CollatorChosen {

7090

1

						round: round as u32,

7091

1

						collator_account: 3,

7092

1

						total_exposed_amount: 400,

7093

1

},

7094

1

					Event::CollatorChosen {

7095

1

						round: round as u32,

7096

1

						collator_account: 4,

7097

1

						total_exposed_amount: 400,

7098

1

},

7099

1

					Event::NewRound {

7100

1

						starting_block: (round as u32 - 1) * 5,

7101

1

						round: round as u32,

7102

1

						selected_collators_number: 4,

7103

1

						total_balance: 1600,

7104

1

},

7105

1

);

7106

7107

1

				set_round_points(round);

7108

1

7109

1

				roll_blocks(1);

7110

1

				assert_events_eq!(

7111

1

					Event::Rewarded {

7112

1

						account: 3,

7113

1

						rewards: 13,

7114

1

},

7115

1

					Event::Rewarded {

7116

1

						account: 22,

7117

1

						rewards: 4,

7118

1

},

7119

1

					Event::Rewarded {

7120

1

						account: 33,

7121

1

						rewards: 4,

7122

1

},

7123

1

);

7124

7125

1

				roll_blocks(1);

7126

1

				assert_events_eq!(

7127

1

					Event::Rewarded {

7128

1

						account: 4,

7129

1

						rewards: 13,

7130

1

},

7131

1

					Event::Rewarded {

7132

1

						account: 33,

7133

1

						rewards: 4,

7134

1

},

7135

1

					Event::Rewarded {

7136

1

						account: 44,

7137

1

						rewards: 4,

7138

1

},

7139

1

);

7140

7141

1

				roll_blocks(1);

7142

1

				assert_events_eq!(

7143

1

					Event::Rewarded {

7144

1

						account: 1,

7145

1

						rewards: 27,

7146

1

},

7147

1

					Event::Rewarded {

7148

1

						account: 11,

7149

1

						rewards: 9,

7150

1

},

7151

1

					Event::Rewarded {

7152

1

						account: 44,

7153

1

						rewards: 9,

7154

1

},

7155

1

);

7156

7157

1

				roll_blocks(1);

7158

1

				assert_events_eq!(

7159

1

					Event::Rewarded {

7160

1

						account: 2,

7161

1

						rewards: 13,

7162

1

},

7163

1

					Event::Rewarded {

7164

1

						account: 11,

7165

1

						rewards: 4,

7166

1

},

7167

1

					Event::Rewarded {

7168

1

						account: 22,

7169

1

						rewards: 4,

7170

1

},

7171

1

);

7172

7173

1

				roll_blocks(1);

7174

1

				// Since we defer first deferred staking payout, this test have the maximum amout of

7175

1

				// supported collators. This eman that the next round is trigerred one block after

7176

1

				// the last reward.

7177

1

				//assert_no_events!();

7178

1

7179

1

				let num_rounds_rolled = roll_to_round_end(round);

7180

1

				assert_eq!(num_rounds_rolled, 0, "expected to be at round end already");

7181

7182

1

				reset_issuance();

7183

1

7184

1

				round + 1

7185

1

};

7186

7187

1

			let mut round = 1;

7188

1

			round = roll_through_initial_rounds(round); // we should be at RewardPaymentDelay

7189

2

			for _ in 1..2 {

7190

1

				round = roll_through_steady_state_round(round);

7191

1

7192

1

});

7193

1

7194

7195

#[test]

7196

1

fn delegation_kicked_from_bottom_removes_pending_request() {

7197

1

	ExtBuilder::default()

7198

1

		.with_balances(vec![

7199

1

			(1, 30),

7200

1

			(2, 29),

7201

1

			(3, 20),

7202

1

			(4, 20),

7203

1

			(5, 20),

7204

1

			(6, 20),

7205

1

			(7, 20),

7206

1

			(8, 20),

7207

1

			(9, 20),

7208

1

			(10, 20),

7209

1

			(11, 30),

7210

1

])

7211

1

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

7212

1

		.with_delegations(vec![

7213

1

			(2, 1, 19),

7214

1

			(2, 11, 10), // second delegation so not left after first is kicked

7215

1

			(3, 1, 20),

7216

1

			(4, 1, 20),

7217

1

			(5, 1, 20),

7218

1

			(6, 1, 20),

7219

1

			(7, 1, 20),

7220

1

			(8, 1, 20),

7221

1

			(9, 1, 20),

7222

1

])

7223

1

		.build()

7224

1

		.execute_with(|| {

7225

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7226

1

				RuntimeOrigin::signed(2),

7227

1

7228

1

));

7229

			// 10 delegates to full 1 => kicks lowest delegation (2, 19)

7230

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

7231

1

				RuntimeOrigin::signed(10),

7232

1

1,

7233

1

20,

7234

1

				Percent::zero(),

7235

1

8,

7236

1

0,

7237

1

0,

7238

1

));

7239

			// check the event

7240

1

			assert_events_emitted!(Event::DelegationKicked {

7241

1

				delegator: 2,

7242

1

				candidate: 1,

7243

1

				unstaked_amount: 19,

7244

1

});

7245

1

			// ensure request DNE

7246

1

			assert!(!ParachainStaking::delegation_scheduled_requests(&1)

7247

1

				.iter()

7248

1

				.any(|x| x.delegator == 2));

7249

1

});

7250

1

7251

7252

#[test]

7253

1

fn no_selected_candidates_defaults_to_last_round_collators() {

7254

1

	ExtBuilder::default()

7255

1

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

7256

1

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

7257

1

		.build()

7258

1

		.execute_with(|| {

7259

1

			roll_to_round_begin(1);

7260

			// schedule to leave

7261

6

			for i in 1..6 {

7262

5

				assert_ok!(ParachainStaking::schedule_leave_candidates(

7263

5

					RuntimeOrigin::signed(i),

7264

5

7265

5

));

7266

7267

1

			let old_round = ParachainStaking::round().current;

7268

1

			let old_selected_candidates = ParachainStaking::selected_candidates();

7269

1

			let mut old_at_stake_snapshots = Vec::new();

7270

5

			for account in old_selected_candidates.clone() {

7271

5

				old_at_stake_snapshots.push(<AtStake<Test>>::get(old_round, account));

7272

5

7273

1

			roll_to_round_begin(3);

7274

			// execute leave

7275

6

			for i in 1..6 {

7276

5

				assert_ok!(ParachainStaking::execute_leave_candidates(

7277

5

					RuntimeOrigin::signed(i),

7278

5

i,

7279

5

0,

7280

5

));

7281

7282

			// next round

7283

1

			roll_to_round_begin(4);

7284

1

			let new_round = ParachainStaking::round().current;

7285

1

			// check AtStake matches previous

7286

1

			let new_selected_candidates = ParachainStaking::selected_candidates();

7287

1

			assert_eq!(old_selected_candidates, new_selected_candidates);

7288

1

			let mut index = 0usize;

7289

6

			for account in new_selected_candidates {

7290

5

				assert_eq!(

7291

5

					old_at_stake_snapshots[index],

7292

5

					<AtStake<Test>>::get(new_round, account)

7293

5

);

7294

5

				index += 1usize;

7295

7296

1

});

7297

1

7298

7299

#[test]

7300

1

fn test_delegator_scheduled_for_revoke_is_rewarded_for_previous_rounds_but_not_for_future() {

7301

1

	ExtBuilder::default()

7302

1

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

7303

1

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

7304

1

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

7305

1

		.build()

7306

1

		.execute_with(|| {

7307

1

			// preset rewards for rounds 1, 2 and 3

7308

3

			(1..=3).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

7309

1

7310

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7311

1

				RuntimeOrigin::signed(2),

7312

1

7313

1

));

7314

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

7315

1

				round: 1,

7316

1

				delegator: 2,

7317

1

				candidate: 1,

7318

1

				scheduled_exit: 3,

7319

1

});

7320

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

7321

1

			assert_eq!(

7322

				1, collator.delegation_count,

7323

				"collator's delegator count was reduced unexpectedly"

7324

);

7325

1

			assert_eq!(

7326

				30, collator.total_counted,

7327

				"collator's total was reduced unexpectedly"

7328

);

7329

7330

1

			roll_to_round_begin(3);

7331

1

			assert_events_emitted_match!(Event::NewRound { round: 3, .. });

7332

1

			roll_blocks(3);

7333

1

			assert_events_eq!(

7334

1

				Event::Rewarded {

7335

1

					account: 1,

7336

1

					rewards: 2,

7337

1

},

7338

1

				Event::Rewarded {

7339

1

					account: 2,

7340

1

					rewards: 1,

7341

1

},

7342

1

);

7343

7344

1

			roll_to_round_begin(4);

7345

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

7346

1

			roll_blocks(3);

7347

1

			assert_events_eq!(Event::Rewarded {

7348

1

				account: 1,

7349

1

				rewards: 2,

7350

1

			},);

7351

1

			let collator_snapshot =

7352

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

7353

1

					.unwrap_or_default();

7354

1

			assert_eq!(

7355

1

1,

7356

1

				collator_snapshot.delegations.len(),

7357

				"collator snapshot's delegator count was reduced unexpectedly"

7358

);

7359

1

			assert_eq!(

7360

				20, collator_snapshot.total,

7361

				"collator snapshot's total was reduced unexpectedly",

7362

);

7363

1

});

7364

1

7365

7366

#[test]

7367

1

fn test_delegator_scheduled_for_revoke_is_rewarded_when_request_cancelled() {

7368

1

	ExtBuilder::default()

7369

1

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

7370

1

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

7371

1

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

7372

1

		.build()

7373

1

		.execute_with(|| {

7374

1

			// preset rewards for rounds 2, 3 and 4

7375

3

			(2..=4).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

7376

1

7377

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7378

1

				RuntimeOrigin::signed(2),

7379

1

7380

1

));

7381

1

			assert_events_eq!(Event::DelegationRevocationScheduled {

7382

1

				round: 1,

7383

1

				delegator: 2,

7384

1

				candidate: 1,

7385

1

				scheduled_exit: 3,

7386

1

});

7387

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

7388

1

			assert_eq!(

7389

				1, collator.delegation_count,

7390

				"collator's delegator count was reduced unexpectedly"

7391

);

7392

1

			assert_eq!(

7393

				30, collator.total_counted,

7394

				"collator's total was reduced unexpectedly"

7395

);

7396

7397

1

			roll_to_round_begin(2);

7398

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

7399

1

				RuntimeOrigin::signed(2),

7400

1

7401

1

));

7402

7403

1

			roll_to_round_begin(4);

7404

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

7405

1

			roll_blocks(3);

7406

1

			assert_events_eq!(Event::Rewarded {

7407

1

				account: 1,

7408

1

				rewards: 2,

7409

1

			},);

7410

1

			let collator_snapshot =

7411

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

7412

1

					.unwrap_or_default();

7413

1

			assert_eq!(

7414

1

1,

7415

1

				collator_snapshot.delegations.len(),

7416

				"collator snapshot's delegator count was reduced unexpectedly"

7417

);

7418

1

			assert_eq!(

7419

				30, collator_snapshot.total,

7420

				"collator snapshot's total was reduced unexpectedly",

7421

);

7422

7423

1

			roll_to_round_begin(5);

7424

1

			assert_events_emitted_match!(Event::NewRound { round: 5, .. });

7425

1

			roll_blocks(3);

7426

1

			assert_events_eq!(

7427

1

				Event::Rewarded {

7428

1

					account: 1,

7429

1

					rewards: 1,

7430

1

},

7431

1

				Event::Rewarded {

7432

1

					account: 2,

7433

1

					rewards: 1,

7434

1

},

7435

1

);

7436

1

});

7437

1

7438

7439

#[test]

7440

1

fn test_delegator_scheduled_for_bond_decrease_is_rewarded_for_previous_rounds_but_less_for_future()

7441

1

7442

1

	ExtBuilder::default()

7443

1

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

7444

1

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

7445

1

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

7446

1

		.build()

7447

1

		.execute_with(|| {

7448

1

			// preset rewards for rounds 1, 2 and 3

7449

3

			(1..=3).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

7450

1

7451

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

7452

1

				RuntimeOrigin::signed(2),

7453

1

1,

7454

1

10,

7455

1

));

7456

1

			assert_events_eq!(Event::DelegationDecreaseScheduled {

7457

1

				execute_round: 3,

7458

1

				delegator: 2,

7459

1

				candidate: 1,

7460

1

				amount_to_decrease: 10,

7461

1

});

7462

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

7463

1

			assert_eq!(

7464

				1, collator.delegation_count,

7465

				"collator's delegator count was reduced unexpectedly"

7466

);

7467

1

			assert_eq!(

7468

				40, collator.total_counted,

7469

				"collator's total was reduced unexpectedly"

7470

);

7471

7472

1

			roll_to_round_begin(3);

7473

1

			assert_events_emitted_match!(Event::NewRound { round: 3, .. });

7474

1

			roll_blocks(3);

7475

1

			assert_events_eq!(

7476

1

				Event::Rewarded {

7477

1

					account: 1,

7478

1

					rewards: 2,

7479

1

},

7480

1

				Event::Rewarded {

7481

1

					account: 2,

7482

1

					rewards: 1,

7483

1

},

7484

1

);

7485

7486

1

			roll_to_round_begin(4);

7487

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

7488

1

			roll_blocks(3);

7489

1

			assert_events_eq!(

7490

1

				Event::Rewarded {

7491

1

					account: 1,

7492

1

					rewards: 1,

7493

1

},

7494

1

				Event::Rewarded {

7495

1

					account: 2,

7496

1

					rewards: 1,

7497

1

},

7498

1

);

7499

1

			let collator_snapshot =

7500

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

7501

1

					.unwrap_or_default();

7502

1

			assert_eq!(

7503

1

1,

7504

1

				collator_snapshot.delegations.len(),

7505

				"collator snapshot's delegator count was reduced unexpectedly"

7506

);

7507

1

			assert_eq!(

7508

				30, collator_snapshot.total,

7509

				"collator snapshot's total was reduced unexpectedly",

7510

);

7511

1

});

7512

1

7513

7514

#[test]

7515

1

fn test_delegator_scheduled_for_bond_decrease_is_rewarded_when_request_cancelled() {

7516

1

	ExtBuilder::default()

7517

1

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

7518

1

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

7519

1

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

7520

1

		.build()

7521

1

		.execute_with(|| {

7522

1

			// preset rewards for rounds 2, 3 and 4

7523

3

			(2..=4).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

7524

1

7525

1

			assert_ok!(ParachainStaking::schedule_delegator_bond_less(

7526

1

				RuntimeOrigin::signed(2),

7527

1

1,

7528

1

10,

7529

1

));

7530

1

			assert_events_eq!(Event::DelegationDecreaseScheduled {

7531

1

				execute_round: 3,

7532

1

				delegator: 2,

7533

1

				candidate: 1,

7534

1

				amount_to_decrease: 10,

7535

1

});

7536

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

7537

1

			assert_eq!(

7538

				1, collator.delegation_count,

7539

				"collator's delegator count was reduced unexpectedly"

7540

);

7541

1

			assert_eq!(

7542

				40, collator.total_counted,

7543

				"collator's total was reduced unexpectedly"

7544

);

7545

7546

1

			roll_to_round_begin(2);

7547

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

7548

1

				RuntimeOrigin::signed(2),

7549

1

7550

1

));

7551

7552

1

			roll_to_round_begin(4);

7553

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

7554

1

			roll_blocks(3);

7555

1

			assert_events_eq!(

7556

1

				Event::Rewarded {

7557

1

					account: 1,

7558

1

					rewards: 1,

7559

1

},

7560

1

				Event::Rewarded {

7561

1

					account: 2,

7562

1

					rewards: 1,

7563

1

},

7564

1

);

7565

1

			let collator_snapshot =

7566

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

7567

1

					.unwrap_or_default();

7568

1

			assert_eq!(

7569

1

1,

7570

1

				collator_snapshot.delegations.len(),

7571

				"collator snapshot's delegator count was reduced unexpectedly"

7572

);

7573

1

			assert_eq!(

7574

				40, collator_snapshot.total,

7575

				"collator snapshot's total was reduced unexpectedly",

7576

);

7577

7578

1

			roll_to_round_begin(5);

7579

1

			assert_events_emitted_match!(Event::NewRound { round: 5, .. });

7580

1

			roll_blocks(3);

7581

1

			assert_events_eq!(

7582

1

				Event::Rewarded {

7583

1

					account: 1,

7584

1

					rewards: 1,

7585

1

},

7586

1

				Event::Rewarded {

7587

1

					account: 2,

7588

1

					rewards: 1,

7589

1

},

7590

1

);

7591

1

});

7592

1

7593

7594

#[test]

7595

1

fn test_delegator_scheduled_for_leave_is_rewarded_for_previous_rounds_but_not_for_future() {

7596

1

	ExtBuilder::default()

7597

1

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

7598

1

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

7599

1

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

7600

1

		.build()

7601

1

		.execute_with(|| {

7602

1

			// preset rewards for rounds 1, 2 and 3

7603

3

			(1..=3).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

7604

1

7605

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7606

1

				RuntimeOrigin::signed(2),

7607

1

1,

7608

1

));

7609

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7610

1

				RuntimeOrigin::signed(2),

7611

1

3,

7612

1

));

7613

1

			assert_events_eq!(

7614

1

				Event::DelegationRevocationScheduled {

7615

1

					round: 1,

7616

1

					delegator: 2,

7617

1

					candidate: 1,

7618

1

					scheduled_exit: 3,

7619

1

},

7620

1

				Event::DelegationRevocationScheduled {

7621

1

					round: 1,

7622

1

					delegator: 2,

7623

1

					candidate: 3,

7624

1

					scheduled_exit: 3,

7625

1

},

7626

1

);

7627

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

7628

1

			assert_eq!(

7629

				1, collator.delegation_count,

7630

				"collator's delegator count was reduced unexpectedly"

7631

);

7632

1

			assert_eq!(

7633

				30, collator.total_counted,

7634

				"collator's total was reduced unexpectedly"

7635

);

7636

7637

1

			roll_to_round_begin(3);

7638

1

			assert_events_emitted_match!(Event::NewRound { round: 3, .. });

7639

1

			roll_blocks(3);

7640

1

			assert_events_eq!(

7641

1

				Event::Rewarded {

7642

1

					account: 1,

7643

1

					rewards: 2,

7644

1

},

7645

1

				Event::Rewarded {

7646

1

					account: 2,

7647

1

					rewards: 1,

7648

1

},

7649

1

);

7650

7651

1

			roll_to_round_begin(4);

7652

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

7653

1

			roll_blocks(3);

7654

1

			assert_events_eq!(Event::Rewarded {

7655

1

				account: 1,

7656

1

				rewards: 2,

7657

1

			},);

7658

1

			let collator_snapshot =

7659

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

7660

1

					.unwrap_or_default();

7661

1

			assert_eq!(

7662

1

1,

7663

1

				collator_snapshot.delegations.len(),

7664

				"collator snapshot's delegator count was reduced unexpectedly"

7665

);

7666

1

			assert_eq!(

7667

				20, collator_snapshot.total,

7668

				"collator snapshot's total was reduced unexpectedly",

7669

);

7670

1

});

7671

1

7672

7673

#[test]

7674

1

fn test_delegator_scheduled_for_leave_is_rewarded_when_request_cancelled() {

7675

1

	ExtBuilder::default()

7676

1

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

7677

1

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

7678

1

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

7679

1

		.build()

7680

1

		.execute_with(|| {

7681

1

			// preset rewards for rounds 2, 3 and 4

7682

3

			(2..=4).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

7683

1

7684

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7685

1

				RuntimeOrigin::signed(2),

7686

1

1,

7687

1

));

7688

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

7689

1

				RuntimeOrigin::signed(2),

7690

1

3,

7691

1

));

7692

1

			assert_events_eq!(

7693

1

				Event::DelegationRevocationScheduled {

7694

1

					round: 1,

7695

1

					delegator: 2,

7696

1

					candidate: 1,

7697

1

					scheduled_exit: 3,

7698

1

},

7699

1

				Event::DelegationRevocationScheduled {

7700

1

					round: 1,

7701

1

					delegator: 2,

7702

1

					candidate: 3,

7703

1

					scheduled_exit: 3,

7704

1

},

7705

1

);

7706

1

			let collator = ParachainStaking::candidate_info(1).expect("candidate must exist");

7707

1

			assert_eq!(

7708

				1, collator.delegation_count,

7709

				"collator's delegator count was reduced unexpectedly"

7710

);

7711

1

			assert_eq!(

7712

				30, collator.total_counted,

7713

				"collator's total was reduced unexpectedly"

7714

);

7715

7716

1

			roll_to_round_begin(2);

7717

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

7718

1

				RuntimeOrigin::signed(2),

7719

1

1,

7720

1

));

7721

1

			assert_ok!(ParachainStaking::cancel_delegation_request(

7722

1

				RuntimeOrigin::signed(2),

7723

1

3,

7724

1

));

7725

7726

1

			roll_to_round_begin(4);

7727

1

			assert_events_emitted_match!(Event::NewRound { round: 4, .. });

7728

1

			roll_blocks(3);

7729

1

			assert_events_eq!(Event::Rewarded {

7730

1

				account: 1,

7731

1

				rewards: 2,

7732

1

			},);

7733

1

			let collator_snapshot =

7734

1

				ParachainStaking::at_stake(ParachainStaking::round().current, 1)

7735

1

					.unwrap_or_default();

7736

1

			assert_eq!(

7737

1

1,

7738

1

				collator_snapshot.delegations.len(),

7739

				"collator snapshot's delegator count was reduced unexpectedly"

7740

);

7741

1

			assert_eq!(

7742

				30, collator_snapshot.total,

7743

				"collator snapshot's total was reduced unexpectedly",

7744

);

7745

7746

1

			roll_to_round_begin(5);

7747

1

			assert_events_emitted_match!(Event::NewRound { round: 5, .. });

7748

1

			roll_blocks(3);

7749

1

			assert_events_eq!(

7750

1

				Event::Rewarded {

7751

1

					account: 1,

7752

1

					rewards: 1,

7753

1

},

7754

1

				Event::Rewarded {

7755

1

					account: 2,

7756

1

					rewards: 1,

7757

1

},

7758

1

);

7759

1

});

7760

1

7761

7762

#[test]

7763

1

fn test_delegation_request_exists_returns_false_when_nothing_exists() {

7764

1

	ExtBuilder::default()

7765

1

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

7766

1

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

7767

1

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

7768

1

		.build()

7769

1

		.execute_with(|| {

7770

1

			assert!(!ParachainStaking::delegation_request_exists(&1, &2));

7771

1

});

7772

1

7773

7774

#[test]

7775

1

fn test_delegation_request_exists_returns_true_when_decrease_exists() {

7776

1

	ExtBuilder::default()

7777

1

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

7778

1

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

7779

1

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

7780

1

		.build()

7781

1

		.execute_with(|| {

7782

1

			<DelegationScheduledRequests<Test>>::insert(

7783

1

1,

7784

1

				BoundedVec::try_from(vec![ScheduledRequest {

7785

1

					delegator: 2,

7786

1

					when_executable: 3,

7787

1

					action: DelegationAction::Decrease(5),

7788

1

}])

7789

1

				.expect("must succeed"),

7790

1

);

7791

1

			assert!(ParachainStaking::delegation_request_exists(&1, &2));

7792

1

});

7793

1

7794

7795

#[test]

7796

1

fn test_delegation_request_exists_returns_true_when_revoke_exists() {

7797

1

	ExtBuilder::default()

7798

1

		.with_balances(vec![(1, 30), (2, 25)])

7799

1

		.with_candidates(vec![(1, 30)])

7800

1

		.with_delegations(vec![(2, 1, 10)])

7801

1

		.build()

7802

1

		.execute_with(|| {

7803

1

			<DelegationScheduledRequests<Test>>::insert(

7804

1

1,

7805

1

				BoundedVec::try_from(vec![ScheduledRequest {

7806

1

					delegator: 2,

7807

1

					when_executable: 3,

7808

1

					action: DelegationAction::Revoke(5),

7809

1

}])

7810

1

				.expect("must succeed"),

7811

1

);

7812

1

			assert!(ParachainStaking::delegation_request_exists(&1, &2));

7813

1

});

7814

1

7815

7816

#[test]

7817

1

fn test_delegation_request_revoke_exists_returns_false_when_nothing_exists() {

7818

1

	ExtBuilder::default()

7819

1

		.with_balances(vec![(1, 30), (2, 25)])

7820

1

		.with_candidates(vec![(1, 30)])

7821

1

		.with_delegations(vec![(2, 1, 10)])

7822

1

		.build()

7823

1

		.execute_with(|| {

7824

1

			assert!(!ParachainStaking::delegation_request_revoke_exists(&1, &2));

7825

1

});

7826

1

7827

7828

#[test]

7829

1

fn test_delegation_request_revoke_exists_returns_false_when_decrease_exists() {

7830

1

	ExtBuilder::default()

7831

1

		.with_balances(vec![(1, 30), (2, 25)])

7832

1

		.with_candidates(vec![(1, 30)])

7833

1

		.with_delegations(vec![(2, 1, 10)])

7834

1

		.build()

7835

1

		.execute_with(|| {

7836

1

			<DelegationScheduledRequests<Test>>::insert(

7837

1

1,

7838

1

				BoundedVec::try_from(vec![ScheduledRequest {

7839

1

					delegator: 2,

7840

1

					when_executable: 3,

7841

1

					action: DelegationAction::Decrease(5),

7842

1

}])

7843

1

				.expect("must succeed"),

7844

1

);

7845

1

			assert!(!ParachainStaking::delegation_request_revoke_exists(&1, &2));

7846

1

});

7847

1

7848

7849

#[test]

7850

1

fn test_delegation_request_revoke_exists_returns_true_when_revoke_exists() {

7851

1

	ExtBuilder::default()

7852

1

		.with_balances(vec![(1, 30), (2, 25)])

7853

1

		.with_candidates(vec![(1, 30)])

7854

1

		.with_delegations(vec![(2, 1, 10)])

7855

1

		.build()

7856

1

		.execute_with(|| {

7857

1

			<DelegationScheduledRequests<Test>>::insert(

7858

1

1,

7859

1

				BoundedVec::try_from(vec![ScheduledRequest {

7860

1

					delegator: 2,

7861

1

					when_executable: 3,

7862

1

					action: DelegationAction::Revoke(5),

7863

1

}])

7864

1

				.expect("must succeed"),

7865

1

);

7866

1

			assert!(ParachainStaking::delegation_request_revoke_exists(&1, &2));

7867

1

});

7868

1

7869

7870

#[test]

7871

1

fn test_hotfix_remove_delegation_requests_exited_candidates_cleans_up() {

7872

1

	ExtBuilder::default()

7873

1

		.with_balances(vec![(1, 20)])

7874

1

		.with_candidates(vec![(1, 20)])

7875

1

		.build()

7876

1

		.execute_with(|| {

7877

1

			// invalid state

7878

1

			<DelegationScheduledRequests<Test>>::insert(2, BoundedVec::default());

7879

1

			<DelegationScheduledRequests<Test>>::insert(3, BoundedVec::default());

7880

1

			assert_ok!(

7881

1

				ParachainStaking::hotfix_remove_delegation_requests_exited_candidates(

7882

1

					RuntimeOrigin::signed(1),

7883

1

					vec![2, 3, 4] // 4 does not exist, but is OK for idempotency

7884

1

7885

1

);

7886

7887

1

			assert!(!<DelegationScheduledRequests<Test>>::contains_key(2));

7888

1

			assert!(!<DelegationScheduledRequests<Test>>::contains_key(3));

7889

1

});

7890

1

7891

7892

#[test]

7893

1

fn test_hotfix_remove_delegation_requests_exited_candidates_cleans_up_only_specified_keys() {

7894

1

	ExtBuilder::default()

7895

1

		.with_balances(vec![(1, 20)])

7896

1

		.with_candidates(vec![(1, 20)])

7897

1

		.build()

7898

1

		.execute_with(|| {

7899

1

			// invalid state

7900

1

			<DelegationScheduledRequests<Test>>::insert(2, BoundedVec::default());

7901

1

			<DelegationScheduledRequests<Test>>::insert(3, BoundedVec::default());

7902

1

			assert_ok!(

7903

1

				ParachainStaking::hotfix_remove_delegation_requests_exited_candidates(

7904

1

					RuntimeOrigin::signed(1),

7905

1

					vec![2]

7906

1

7907

1

);

7908

7909

1

			assert!(!<DelegationScheduledRequests<Test>>::contains_key(2));

7910

1

			assert!(<DelegationScheduledRequests<Test>>::contains_key(3));

7911

1

});

7912

1

7913

7914

#[test]

7915

1

fn test_hotfix_remove_delegation_requests_exited_candidates_errors_when_requests_not_empty() {

7916

1

	ExtBuilder::default()

7917

1

		.with_balances(vec![(1, 20)])

7918

1

		.with_candidates(vec![(1, 20)])

7919

1

		.build()

7920

1

		.execute_with(|| {

7921

1

			// invalid state

7922

1

			<DelegationScheduledRequests<Test>>::insert(2, BoundedVec::default());

7923

1

			<DelegationScheduledRequests<Test>>::insert(

7924

1

3,

7925

1

				BoundedVec::try_from(vec![ScheduledRequest {

7926

1

					delegator: 10,

7927

1

					when_executable: 1,

7928

1

					action: DelegationAction::Revoke(10),

7929

1

}])

7930

1

				.expect("must succeed"),

7931

1

);

7932

1

7933

1

			assert_noop!(

7934

1

				ParachainStaking::hotfix_remove_delegation_requests_exited_candidates(

7935

1

					RuntimeOrigin::signed(1),

7936

1

					vec![2, 3]

7937

1

),

7938

1

				<Error<Test>>::CandidateNotLeaving,

7939

1

);

7940

1

});

7941

1

7942

7943

#[test]

7944

1

fn test_hotfix_remove_delegation_requests_exited_candidates_errors_when_candidate_not_exited() {

7945

1

	ExtBuilder::default()

7946

1

		.with_balances(vec![(1, 20)])

7947

1

		.with_candidates(vec![(1, 20)])

7948

1

		.build()

7949

1

		.execute_with(|| {

7950

1

			// invalid state

7951

1

			<DelegationScheduledRequests<Test>>::insert(1, BoundedVec::default());

7952

1

			assert_noop!(

7953

1

				ParachainStaking::hotfix_remove_delegation_requests_exited_candidates(

7954

1

					RuntimeOrigin::signed(1),

7955

1

					vec![1]

7956

1

),

7957

1

				<Error<Test>>::CandidateNotLeaving,

7958

1

);

7959

1

});

7960

1

7961

7962

#[test]

7963

1

fn locking_zero_amount_removes_lock() {

7964

	use frame_support::traits::{LockableCurrency, WithdrawReasons};

7965

7966

	// this test demonstrates the behavior of pallet Balance's `LockableCurrency` implementation of

7967

	// `set_locks()` when an amount of 0 is provided: any previous lock is removed

7968

7969

1

	ExtBuilder::default()

7970

1

		.with_balances(vec![(1, 100)])

7971

1

		.build()

7972

1

		.execute_with(|| {

7973

1

			assert_eq!(crate::mock::query_lock_amount(1, DELEGATOR_LOCK_ID), None);

7974

7975

1

			Balances::set_lock(DELEGATOR_LOCK_ID, &1, 1, WithdrawReasons::all());

7976

1

			assert_eq!(

7977

1

				crate::mock::query_lock_amount(1, DELEGATOR_LOCK_ID),

7978

1

				Some(1)

7979

1

);

7980

7981

1

			Balances::set_lock(DELEGATOR_LOCK_ID, &1, 0, WithdrawReasons::all());

7982

1

			// Note that we tried to call `set_lock(0)` and the previous lock gets removed

7983

1

			assert_eq!(crate::mock::query_lock_amount(1, DELEGATOR_LOCK_ID), None);

7984

1

});

7985

1

7986

7987

#[test]

7988

1

fn revoke_last_removes_lock() {

7989

1

	ExtBuilder::default()

7990

1

		.with_balances(vec![(1, 100), (2, 100), (3, 100)])

7991

1

		.with_candidates(vec![(1, 25), (2, 25)])

7992

1

		.with_delegations(vec![(3, 1, 30), (3, 2, 25)])

7993

1

		.build()

7994

1

		.execute_with(|| {

7995

1

			assert_eq!(

7996

1

				crate::mock::query_lock_amount(3, DELEGATOR_LOCK_ID),

7997

1

				Some(55)

7998

1

);

7999

8000

			// schedule and remove one...

8001

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8002

1

				RuntimeOrigin::signed(3),

8003

1

8004

1

));

8005

1

			roll_to_round_begin(3);

8006

1

			assert_ok!(ParachainStaking::execute_delegation_request(

8007

1

				RuntimeOrigin::signed(3),

8008

1

3,

8009

1

8010

1

));

8011

1

			assert_eq!(

8012

1

				crate::mock::query_lock_amount(3, DELEGATOR_LOCK_ID),

8013

1

				Some(25)

8014

1

);

8015

8016

			// schedule and remove the other...

8017

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8018

1

				RuntimeOrigin::signed(3),

8019

1

8020

1

));

8021

1

			roll_to_round_begin(5);

8022

1

			assert_ok!(ParachainStaking::execute_delegation_request(

8023

1

				RuntimeOrigin::signed(3),

8024

1

3,

8025

1

8026

1

));

8027

1

			assert_eq!(crate::mock::query_lock_amount(3, DELEGATOR_LOCK_ID), None);

8028

1

});

8029

1

8030

8031

#[test]

8032

1

fn test_set_auto_compound_fails_if_invalid_delegation_hint() {

8033

1

	ExtBuilder::default()

8034

1

		.with_balances(vec![(1, 30), (2, 25)])

8035

1

		.with_candidates(vec![(1, 30)])

8036

1

		.with_delegations(vec![(2, 1, 10)])

8037

1

		.build()

8038

1

		.execute_with(|| {

8039

1

			let candidate_auto_compounding_delegation_count_hint = 0;

8040

1

			let delegation_hint = 0; // is however, 1

8041

1

8042

1

			assert_noop!(

8043

1

				ParachainStaking::set_auto_compound(

8044

1

					RuntimeOrigin::signed(2),

8045

1

1,

8046

1

					Percent::from_percent(50),

8047

1

					candidate_auto_compounding_delegation_count_hint,

8048

1

					delegation_hint,

8049

1

),

8050

1

				<Error<Test>>::TooLowDelegationCountToAutoCompound,

8051

1

);

8052

1

});

8053

1

8054

8055

#[test]

8056

1

fn test_set_auto_compound_fails_if_invalid_candidate_auto_compounding_hint() {

8057

1

	ExtBuilder::default()

8058

1

		.with_balances(vec![(1, 30), (2, 25)])

8059

1

		.with_candidates(vec![(1, 30)])

8060

1

		.with_delegations(vec![(2, 1, 10)])

8061

1

		.build()

8062

1

		.execute_with(|| {

8063

1

			<AutoCompoundDelegations<Test>>::new(

8064

1

				vec![AutoCompoundConfig {

8065

1

					delegator: 2,

8066

1

					value: Percent::from_percent(10),

8067

1

}]

8068

1

				.try_into()

8069

1

				.expect("must succeed"),

8070

1

8071

1

			.set_storage(&1);

8072

1

			let candidate_auto_compounding_delegation_count_hint = 0; // is however, 1

8073

1

			let delegation_hint = 1;

8074

1

8075

1

			assert_noop!(

8076

1

				ParachainStaking::set_auto_compound(

8077

1

					RuntimeOrigin::signed(2),

8078

1

1,

8079

1

					Percent::from_percent(50),

8080

1

					candidate_auto_compounding_delegation_count_hint,

8081

1

					delegation_hint,

8082

1

),

8083

1

				<Error<Test>>::TooLowCandidateAutoCompoundingDelegationCountToAutoCompound,

8084

1

);

8085

1

});

8086

1

8087

8088

#[test]

8089

1

fn test_set_auto_compound_inserts_if_not_exists() {

8090

1

	ExtBuilder::default()

8091

1

		.with_balances(vec![(1, 30), (2, 25)])

8092

1

		.with_candidates(vec![(1, 30)])

8093

1

		.with_delegations(vec![(2, 1, 10)])

8094

1

		.build()

8095

1

		.execute_with(|| {

8096

1

			assert_ok!(ParachainStaking::set_auto_compound(

8097

1

				RuntimeOrigin::signed(2),

8098

1

1,

8099

1

				Percent::from_percent(50),

8100

1

0,

8101

1

1,

8102

1

));

8103

1

			assert_events_emitted!(Event::AutoCompoundSet {

8104

1

				candidate: 1,

8105

1

				delegator: 2,

8106

1

				value: Percent::from_percent(50),

8107

1

});

8108

1

			assert_eq!(

8109

1

				vec![AutoCompoundConfig {

8110

1

					delegator: 2,

8111

1

					value: Percent::from_percent(50),

8112

1

}],

8113

1

				ParachainStaking::auto_compounding_delegations(&1).into_inner(),

8114

1

);

8115

1

});

8116

1

8117

8118

#[test]

8119

1

fn test_set_auto_compound_updates_if_existing() {

8120

1

	ExtBuilder::default()

8121

1

		.with_balances(vec![(1, 30), (2, 25)])

8122

1

		.with_candidates(vec![(1, 30)])

8123

1

		.with_delegations(vec![(2, 1, 10)])

8124

1

		.build()

8125

1

		.execute_with(|| {

8126

1

			<AutoCompoundDelegations<Test>>::new(

8127

1

				vec![AutoCompoundConfig {

8128

1

					delegator: 2,

8129

1

					value: Percent::from_percent(10),

8130

1

}]

8131

1

				.try_into()

8132

1

				.expect("must succeed"),

8133

1

8134

1

			.set_storage(&1);

8135

1

8136

1

			assert_ok!(ParachainStaking::set_auto_compound(

8137

1

				RuntimeOrigin::signed(2),

8138

1

1,

8139

1

				Percent::from_percent(50),

8140

1

1,

8141

1

1,

8142

1

));

8143

1

			assert_events_emitted!(Event::AutoCompoundSet {

8144

1

				candidate: 1,

8145

1

				delegator: 2,

8146

1

				value: Percent::from_percent(50),

8147

1

});

8148

1

			assert_eq!(

8149

1

				vec![AutoCompoundConfig {

8150

1

					delegator: 2,

8151

1

					value: Percent::from_percent(50),

8152

1

}],

8153

1

				ParachainStaking::auto_compounding_delegations(&1).into_inner(),

8154

1

);

8155

1

});

8156

1

8157

8158

#[test]

8159

1

fn test_set_auto_compound_removes_if_auto_compound_zero_percent() {

8160

1

	ExtBuilder::default()

8161

1

		.with_balances(vec![(1, 30), (2, 25)])

8162

1

		.with_candidates(vec![(1, 30)])

8163

1

		.with_delegations(vec![(2, 1, 10)])

8164

1

		.build()

8165

1

		.execute_with(|| {

8166

1

			<AutoCompoundDelegations<Test>>::new(

8167

1

				vec![AutoCompoundConfig {

8168

1

					delegator: 2,

8169

1

					value: Percent::from_percent(10),

8170

1

}]

8171

1

				.try_into()

8172

1

				.expect("must succeed"),

8173

1

8174

1

			.set_storage(&1);

8175

1

8176

1

			assert_ok!(ParachainStaking::set_auto_compound(

8177

1

				RuntimeOrigin::signed(2),

8178

1

1,

8179

1

				Percent::zero(),

8180

1

1,

8181

1

1,

8182

1

));

8183

1

			assert_events_emitted!(Event::AutoCompoundSet {

8184

1

				candidate: 1,

8185

1

				delegator: 2,

8186

1

				value: Percent::zero(),

8187

1

});

8188

1

			assert_eq!(0, ParachainStaking::auto_compounding_delegations(&1).len(),);

8189

1

});

8190

1

8191

8192

#[test]

8193

1

fn test_execute_revoke_delegation_removes_auto_compounding_from_state_for_delegation_revoke() {

8194

1

	ExtBuilder::default()

8195

1

		.with_balances(vec![(1, 30), (2, 30), (3, 20)])

8196

1

		.with_candidates(vec![(1, 30), (3, 20)])

8197

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

8198

1

		.build()

8199

1

		.execute_with(|| {

8200

1

			assert_ok!(ParachainStaking::set_auto_compound(

8201

1

				RuntimeOrigin::signed(2),

8202

1

1,

8203

1

				Percent::from_percent(50),

8204

1

0,

8205

1

2,

8206

1

));

8207

1

			assert_ok!(ParachainStaking::set_auto_compound(

8208

1

				RuntimeOrigin::signed(2),

8209

1

3,

8210

1

				Percent::from_percent(50),

8211

1

0,

8212

1

2,

8213

1

));

8214

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8215

1

				RuntimeOrigin::signed(2),

8216

1

8217

1

));

8218

1

			roll_to(10);

8219

1

			assert_ok!(ParachainStaking::execute_delegation_request(

8220

1

				RuntimeOrigin::signed(2),

8221

1

2,

8222

1

8223

1

));

8224

1

			assert!(

8225

1

				!ParachainStaking::auto_compounding_delegations(&1)

8226

1

					.iter()

8227

1

					.any(|x| x.delegator == 2),

8228

				"delegation auto-compound config was not removed"

8229

);

8230

1

			assert!(

8231

1

				ParachainStaking::auto_compounding_delegations(&3)

8232

1

					.iter()

8233

1

					.any(|x| x.delegator == 2),

8234

				"delegation auto-compound config was erroneously removed"

8235

);

8236

1

});

8237

1

8238

8239

#[test]

8240

1

fn test_execute_leave_delegators_removes_auto_compounding_state() {

8241

1

	ExtBuilder::default()

8242

1

		.with_balances(vec![(1, 30), (2, 20), (3, 20)])

8243

1

		.with_candidates(vec![(1, 30), (3, 20)])

8244

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

8245

1

		.build()

8246

1

		.execute_with(|| {

8247

1

			assert_ok!(ParachainStaking::set_auto_compound(

8248

1

				RuntimeOrigin::signed(2),

8249

1

1,

8250

1

				Percent::from_percent(50),

8251

1

0,

8252

1

2,

8253

1

));

8254

1

			assert_ok!(ParachainStaking::set_auto_compound(

8255

1

				RuntimeOrigin::signed(2),

8256

1

3,

8257

1

				Percent::from_percent(50),

8258

1

0,

8259

1

2,

8260

1

));

8261

8262

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8263

1

				RuntimeOrigin::signed(2),

8264

1

1,

8265

1

));

8266

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8267

1

				RuntimeOrigin::signed(2),

8268

1

3,

8269

1

));

8270

1

			roll_to(10);

8271

1

			assert_ok!(ParachainStaking::execute_delegation_request(

8272

1

				RuntimeOrigin::signed(2),

8273

1

2,

8274

1

1,

8275

1

));

8276

1

			assert_ok!(ParachainStaking::execute_delegation_request(

8277

1

				RuntimeOrigin::signed(2),

8278

1

2,

8279

1

3,

8280

1

));

8281

8282

1

			assert!(

8283

1

				!ParachainStaking::auto_compounding_delegations(&1)

8284

1

					.iter()

8285

1

					.any(|x| x.delegator == 2),

8286

				"delegation auto-compound config was not removed"

8287

);

8288

1

			assert!(

8289

1

				!ParachainStaking::auto_compounding_delegations(&3)

8290

1

					.iter()

8291

1

					.any(|x| x.delegator == 2),

8292

				"delegation auto-compound config was not removed"

8293

);

8294

1

});

8295

1

8296

8297

#[test]

8298

1

fn test_execute_leave_candidates_removes_auto_compounding_state() {

8299

1

	ExtBuilder::default()

8300

1

		.with_balances(vec![(1, 30), (2, 20), (3, 20)])

8301

1

		.with_candidates(vec![(1, 30), (3, 20)])

8302

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

8303

1

		.build()

8304

1

		.execute_with(|| {

8305

1

			assert_ok!(ParachainStaking::set_auto_compound(

8306

1

				RuntimeOrigin::signed(2),

8307

1

1,

8308

1

				Percent::from_percent(50),

8309

1

0,

8310

1

2,

8311

1

));

8312

1

			assert_ok!(ParachainStaking::set_auto_compound(

8313

1

				RuntimeOrigin::signed(2),

8314

1

3,

8315

1

				Percent::from_percent(50),

8316

1

0,

8317

1

2,

8318

1

));

8319

8320

1

			assert_ok!(ParachainStaking::schedule_leave_candidates(

8321

1

				RuntimeOrigin::signed(1),

8322

1

8323

1

));

8324

1

			roll_to(10);

8325

1

			assert_ok!(ParachainStaking::execute_leave_candidates(

8326

1

				RuntimeOrigin::signed(1),

8327

1

1,

8328

1

1,

8329

1

));

8330

8331

1

			assert!(

8332

1

				!ParachainStaking::auto_compounding_delegations(&1)

8333

1

					.iter()

8334

1

					.any(|x| x.delegator == 2),

8335

				"delegation auto-compound config was not removed"

8336

);

8337

1

			assert!(

8338

1

				ParachainStaking::auto_compounding_delegations(&3)

8339

1

					.iter()

8340

1

					.any(|x| x.delegator == 2),

8341

				"delegation auto-compound config was erroneously removed"

8342

);

8343

1

});

8344

1

8345

8346

#[test]

8347

1

fn test_delegation_kicked_from_bottom_delegation_removes_auto_compounding_state() {

8348

1

	ExtBuilder::default()

8349

1

		.with_balances(vec![

8350

1

			(1, 30),

8351

1

			(2, 29),

8352

1

			(3, 20),

8353

1

			(4, 20),

8354

1

			(5, 20),

8355

1

			(6, 20),

8356

1

			(7, 20),

8357

1

			(8, 20),

8358

1

			(9, 20),

8359

1

			(10, 20),

8360

1

			(11, 30),

8361

1

])

8362

1

		.with_candidates(vec![(1, 30), (11, 30)])

8363

1

		.with_delegations(vec![

8364

1

			(2, 11, 10), // extra delegation to avoid leaving the delegator set

8365

1

			(2, 1, 19),

8366

1

			(3, 1, 20),

8367

1

			(4, 1, 20),

8368

1

			(5, 1, 20),

8369

1

			(6, 1, 20),

8370

1

			(7, 1, 20),

8371

1

			(8, 1, 20),

8372

1

			(9, 1, 20),

8373

1

])

8374

1

		.build()

8375

1

		.execute_with(|| {

8376

1

			assert_ok!(ParachainStaking::set_auto_compound(

8377

1

				RuntimeOrigin::signed(2),

8378

1

1,

8379

1

				Percent::from_percent(50),

8380

1

0,

8381

1

2,

8382

1

));

8383

8384

			// kicks lowest delegation (2, 19)

8385

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8386

1

				RuntimeOrigin::signed(10),

8387

1

1,

8388

1

20,

8389

1

				Percent::zero(),

8390

1

8,

8391

1

0,

8392

1

0,

8393

1

));

8394

8395

1

			assert!(

8396

1

				!ParachainStaking::auto_compounding_delegations(&1)

8397

1

					.iter()

8398

1

					.any(|x| x.delegator == 2),

8399

				"delegation auto-compound config was not removed"

8400

);

8401

1

});

8402

1

8403

8404

#[test]

8405

1

fn test_rewards_do_not_auto_compound_on_payment_if_delegation_scheduled_revoke_exists() {

8406

1

	ExtBuilder::default()

8407

1

		.with_balances(vec![(1, 100), (2, 200), (3, 200)])

8408

1

		.with_candidates(vec![(1, 100)])

8409

1

		.with_delegations(vec![(2, 1, 200), (3, 1, 200)])

8410

1

		.build()

8411

1

		.execute_with(|| {

8412

4

			(2..=5).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

8413

1

			assert_ok!(ParachainStaking::set_auto_compound(

8414

1

				RuntimeOrigin::signed(2),

8415

1

1,

8416

1

				Percent::from_percent(50),

8417

1

0,

8418

1

1,

8419

1

));

8420

1

			assert_ok!(ParachainStaking::set_auto_compound(

8421

1

				RuntimeOrigin::signed(3),

8422

1

1,

8423

1

				Percent::from_percent(50),

8424

1

1,

8425

1

1,

8426

1

));

8427

1

			roll_to_round_begin(3);

8428

1

8429

1

			// schedule revoke for delegator 2; no rewards should be compounded

8430

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8431

1

				RuntimeOrigin::signed(2),

8432

1

8433

1

));

8434

1

			roll_to_round_begin(4);

8435

1

8436

1

			assert_events_eq!(

8437

1

				Event::CollatorChosen {

8438

1

					round: 4,

8439

1

					collator_account: 1,

8440

1

					total_exposed_amount: 500,

8441

1

},

8442

1

				Event::NewRound {

8443

1

					starting_block: 15,

8444

1

					round: 4,

8445

1

					selected_collators_number: 1,

8446

1

					total_balance: 500,

8447

1

},

8448

1

);

8449

8450

1

			roll_blocks(1);

8451

1

			assert_events_eq!(

8452

1

				Event::Rewarded {

8453

1

					account: 1,

8454

1

					rewards: 4,

8455

1

},

8456

1

				// no compound since revoke request exists

8457

1

				Event::Rewarded {

8458

1

					account: 2,

8459

1

					rewards: 4,

8460

1

},

8461

1

				// 50%

8462

1

				Event::Rewarded {

8463

1

					account: 3,

8464

1

					rewards: 4,

8465

1

},

8466

1

				Event::Compounded {

8467

1

					candidate: 1,

8468

1

					delegator: 3,

8469

1

					amount: 2,

8470

1

},

8471

1

);

8472

1

});

8473

1

8474

8475

#[test]

8476

1

fn test_rewards_auto_compound_on_payment_as_per_auto_compound_config() {

8477

1

	ExtBuilder::default()

8478

1

		.with_balances(vec![(1, 100), (2, 200), (3, 200), (4, 200), (5, 200)])

8479

1

		.with_candidates(vec![(1, 100)])

8480

1

		.with_delegations(vec![(2, 1, 200), (3, 1, 200), (4, 1, 200), (5, 1, 200)])

8481

1

		.build()

8482

1

		.execute_with(|| {

8483

5

			(2..=6).for_each(|round| set_author(round, 1, POINTS_PER_ROUND));

8484

1

			assert_ok!(ParachainStaking::set_auto_compound(

8485

1

				RuntimeOrigin::signed(2),

8486

1

1,

8487

1

				Percent::from_percent(0),

8488

1

0,

8489

1

1,

8490

1

));

8491

1

			assert_ok!(ParachainStaking::set_auto_compound(

8492

1

				RuntimeOrigin::signed(3),

8493

1

1,

8494

1

				Percent::from_percent(50),

8495

1

1,

8496

1

1,

8497

1

));

8498

1

			assert_ok!(ParachainStaking::set_auto_compound(

8499

1

				RuntimeOrigin::signed(4),

8500

1

1,

8501

1

				Percent::from_percent(100),

8502

1

2,

8503

1

1,

8504

1

));

8505

1

			roll_to_round_begin(4);

8506

1

8507

1

			assert_events_eq!(

8508

1

				Event::CollatorChosen {

8509

1

					round: 4,

8510

1

					collator_account: 1,

8511

1

					total_exposed_amount: 900,

8512

1

},

8513

1

				Event::NewRound {

8514

1

					starting_block: 15,

8515

1

					round: 4,

8516

1

					selected_collators_number: 1,

8517

1

					total_balance: 900,

8518

1

},

8519

1

);

8520

8521

1

			roll_blocks(1);

8522

1

			assert_events_eq!(

8523

1

				Event::Rewarded {

8524

1

					account: 1,

8525

1

					rewards: 6,

8526

1

},

8527

1

				// 0%

8528

1

				Event::Rewarded {

8529

1

					account: 2,

8530

1

					rewards: 4,

8531

1

},

8532

1

				// 50%

8533

1

				Event::Rewarded {

8534

1

					account: 3,

8535

1

					rewards: 4,

8536

1

},

8537

1

				Event::Compounded {

8538

1

					candidate: 1,

8539

1

					delegator: 3,

8540

1

					amount: 2,

8541

1

},

8542

1

				// 100%

8543

1

				Event::Rewarded {

8544

1

					account: 4,

8545

1

					rewards: 4,

8546

1

},

8547

1

				Event::Compounded {

8548

1

					candidate: 1,

8549

1

					delegator: 4,

8550

1

					amount: 4,

8551

1

},

8552

1

				// no-config

8553

1

				Event::Rewarded {

8554

1

					account: 5,

8555

1

					rewards: 4,

8556

1

},

8557

1

);

8558

1

});

8559

1

8560

8561

#[test]

8562

1

fn test_delegate_with_auto_compound_fails_if_invalid_delegation_hint() {

8563

1

	ExtBuilder::default()

8564

1

		.with_balances(vec![(1, 30), (2, 25), (3, 30)])

8565

1

		.with_candidates(vec![(1, 30), (3, 30)])

8566

1

		.with_delegations(vec![(2, 3, 10)])

8567

1

		.build()

8568

1

		.execute_with(|| {

8569

1

			let candidate_delegation_count_hint = 0;

8570

1

			let candidate_auto_compounding_delegation_count_hint = 0;

8571

1

			let delegation_hint = 0; // is however, 1

8572

1

8573

1

			assert_noop!(

8574

1

				ParachainStaking::delegate_with_auto_compound(

8575

1

					RuntimeOrigin::signed(2),

8576

1

1,

8577

1

10,

8578

1

					Percent::from_percent(50),

8579

1

					candidate_delegation_count_hint,

8580

1

					candidate_auto_compounding_delegation_count_hint,

8581

1

					delegation_hint,

8582

1

),

8583

1

				<Error<Test>>::TooLowDelegationCountToDelegate,

8584

1

);

8585

1

});

8586

1

8587

8588

#[test]

8589

1

fn test_delegate_with_auto_compound_fails_if_invalid_candidate_delegation_count_hint() {

8590

1

	ExtBuilder::default()

8591

1

		.with_balances(vec![(1, 30), (2, 25), (3, 30)])

8592

1

		.with_candidates(vec![(1, 30)])

8593

1

		.with_delegations(vec![(3, 1, 10)])

8594

1

		.build()

8595

1

		.execute_with(|| {

8596

1

			let candidate_delegation_count_hint = 0; // is however, 1

8597

1

			let candidate_auto_compounding_delegation_count_hint = 0;

8598

1

			let delegation_hint = 0;

8599

1

8600

1

			assert_noop!(

8601

1

				ParachainStaking::delegate_with_auto_compound(

8602

1

					RuntimeOrigin::signed(2),

8603

1

1,

8604

1

10,

8605

1

					Percent::from_percent(50),

8606

1

					candidate_delegation_count_hint,

8607

1

					candidate_auto_compounding_delegation_count_hint,

8608

1

					delegation_hint,

8609

1

),

8610

1

				<Error<Test>>::TooLowCandidateDelegationCountToDelegate,

8611

1

);

8612

1

});

8613

1

8614

8615

#[test]

8616

1

fn test_delegate_with_auto_compound_fails_if_invalid_candidate_auto_compounding_delegations_hint() {

8617

1

	ExtBuilder::default()

8618

1

		.with_balances(vec![(1, 30), (2, 25), (3, 30)])

8619

1

		.with_candidates(vec![(1, 30)])

8620

1

		.with_auto_compounding_delegations(vec![(3, 1, 10, Percent::from_percent(10))])

8621

1

		.build()

8622

1

		.execute_with(|| {

8623

1

			let candidate_delegation_count_hint = 1;

8624

1

			let candidate_auto_compounding_delegation_count_hint = 0; // is however, 1

8625

1

			let delegation_hint = 0;

8626

1

8627

1

			assert_noop!(

8628

1

				ParachainStaking::delegate_with_auto_compound(

8629

1

					RuntimeOrigin::signed(2),

8630

1

1,

8631

1

10,

8632

1

					Percent::from_percent(50),

8633

1

					candidate_delegation_count_hint,

8634

1

					candidate_auto_compounding_delegation_count_hint,

8635

1

					delegation_hint,

8636

1

),

8637

1

				<Error<Test>>::TooLowCandidateAutoCompoundingDelegationCountToDelegate,

8638

1

);

8639

1

});

8640

1

8641

8642

#[test]

8643

1

fn test_delegate_with_auto_compound_sets_auto_compound_config() {

8644

1

	ExtBuilder::default()

8645

1

		.with_balances(vec![(1, 30), (2, 25)])

8646

1

		.with_candidates(vec![(1, 30)])

8647

1

		.build()

8648

1

		.execute_with(|| {

8649

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8650

1

				RuntimeOrigin::signed(2),

8651

1

1,

8652

1

10,

8653

1

				Percent::from_percent(50),

8654

1

0,

8655

1

0,

8656

1

0,

8657

1

));

8658

1

			assert_events_emitted!(Event::Delegation {

8659

1

				delegator: 2,

8660

1

				locked_amount: 10,

8661

1

				candidate: 1,

8662

1

				delegator_position: DelegatorAdded::AddedToTop { new_total: 40 },

8663

1

				auto_compound: Percent::from_percent(50),

8664

1

});

8665

1

			assert_eq!(

8666

1

				vec![AutoCompoundConfig {

8667

1

					delegator: 2,

8668

1

					value: Percent::from_percent(50),

8669

1

}],

8670

1

				ParachainStaking::auto_compounding_delegations(&1).into_inner(),

8671

1

);

8672

1

});

8673

1

8674

8675

#[test]

8676

1

fn test_delegate_with_auto_compound_skips_storage_but_emits_event_for_zero_auto_compound() {

8677

1

	ExtBuilder::default()

8678

1

		.with_balances(vec![(1, 30), (2, 10)])

8679

1

		.with_candidates(vec![(1, 30)])

8680

1

		.build()

8681

1

		.execute_with(|| {

8682

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8683

1

				RuntimeOrigin::signed(2),

8684

1

1,

8685

1

10,

8686

1

				Percent::zero(),

8687

1

0,

8688

1

0,

8689

1

0,

8690

1

));

8691

1

			assert_eq!(0, ParachainStaking::auto_compounding_delegations(&1).len(),);

8692

1

			assert_events_eq!(Event::Delegation {

8693

1

				delegator: 2,

8694

1

				locked_amount: 10,

8695

1

				candidate: 1,

8696

1

				delegator_position: DelegatorAdded::AddedToTop { new_total: 40 },

8697

1

				auto_compound: Percent::zero(),

8698

1

});

8699

1

});

8700

1

8701

8702

#[test]

8703

1

fn test_delegate_with_auto_compound_reserves_balance() {

8704

1

	ExtBuilder::default()

8705

1

		.with_balances(vec![(1, 30), (2, 10)])

8706

1

		.with_candidates(vec![(1, 30)])

8707

1

		.build()

8708

1

		.execute_with(|| {

8709

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 10);

8710

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8711

1

				RuntimeOrigin::signed(2),

8712

1

1,

8713

1

10,

8714

1

				Percent::from_percent(50),

8715

1

0,

8716

1

0,

8717

1

0,

8718

1

));

8719

1

			assert_eq!(ParachainStaking::get_delegator_stakable_balance(&2), 0);

8720

1

});

8721

1

8722

8723

#[test]

8724

1

fn test_delegate_with_auto_compound_updates_delegator_state() {

8725

1

	ExtBuilder::default()

8726

1

		.with_balances(vec![(1, 30), (2, 10)])

8727

1

		.with_candidates(vec![(1, 30)])

8728

1

		.build()

8729

1

		.execute_with(|| {

8730

1

			assert!(ParachainStaking::delegator_state(2).is_none());

8731

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8732

1

				RuntimeOrigin::signed(2),

8733

1

1,

8734

1

10,

8735

1

				Percent::from_percent(50),

8736

1

0,

8737

1

0,

8738

1

8739

1

));

8740

1

			let delegator_state =

8741

1

				ParachainStaking::delegator_state(2).expect("just delegated => exists");

8742

1

			assert_eq!(delegator_state.total(), 10);

8743

1

			assert_eq!(delegator_state.delegations.0[0].owner, 1);

8744

1

			assert_eq!(delegator_state.delegations.0[0].amount, 10);

8745

1

});

8746

1

8747

8748

#[test]

8749

1

fn test_delegate_with_auto_compound_updates_collator_state() {

8750

1

	ExtBuilder::default()

8751

1

		.with_balances(vec![(1, 30), (2, 10)])

8752

1

		.with_candidates(vec![(1, 30)])

8753

1

		.build()

8754

1

		.execute_with(|| {

8755

1

			let candidate_state =

8756

1

				ParachainStaking::candidate_info(1).expect("registered in genesis");

8757

1

			assert_eq!(candidate_state.total_counted, 30);

8758

1

			let top_delegations =

8759

1

				ParachainStaking::top_delegations(1).expect("registered in genesis");

8760

1

			assert!(top_delegations.delegations.is_empty());

8761

1

			assert!(top_delegations.total.is_zero());

8762

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8763

1

				RuntimeOrigin::signed(2),

8764

1

1,

8765

1

10,

8766

1

				Percent::from_percent(50),

8767

1

0,

8768

1

0,

8769

1

8770

1

));

8771

1

			let candidate_state =

8772

1

				ParachainStaking::candidate_info(1).expect("just delegated => exists");

8773

1

			assert_eq!(candidate_state.total_counted, 40);

8774

1

			let top_delegations =

8775

1

				ParachainStaking::top_delegations(1).expect("just delegated => exists");

8776

1

			assert_eq!(top_delegations.delegations[0].owner, 2);

8777

1

			assert_eq!(top_delegations.delegations[0].amount, 10);

8778

1

			assert_eq!(top_delegations.total, 10);

8779

1

});

8780

1

8781

8782

#[test]

8783

1

fn test_delegate_with_auto_compound_can_delegate_immediately_after_other_join_candidates() {

8784

1

	ExtBuilder::default()

8785

1

		.with_balances(vec![(1, 20), (2, 20)])

8786

1

		.build()

8787

1

		.execute_with(|| {

8788

1

			assert_ok!(ParachainStaking::join_candidates(

8789

1

				RuntimeOrigin::signed(1),

8790

1

20,

8791

1

8792

1

));

8793

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8794

1

				RuntimeOrigin::signed(2),

8795

1

1,

8796

1

20,

8797

1

				Percent::from_percent(50),

8798

1

0,

8799

1

0,

8800

1

8801

1

));

8802

1

});

8803

1

8804

8805

#[test]

8806

1

fn test_delegate_with_auto_compound_can_delegate_to_other_if_revoking() {

8807

1

	ExtBuilder::default()

8808

1

		.with_balances(vec![(1, 20), (2, 30), (3, 20), (4, 20)])

8809

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20)])

8810

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10)])

8811

1

		.build()

8812

1

		.execute_with(|| {

8813

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8814

1

				RuntimeOrigin::signed(2),

8815

1

8816

1

));

8817

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8818

1

				RuntimeOrigin::signed(2),

8819

1

4,

8820

1

10,

8821

1

				Percent::from_percent(50),

8822

1

0,

8823

1

0,

8824

1

8825

1

));

8826

1

});

8827

1

8828

8829

#[test]

8830

1

fn test_delegate_with_auto_compound_cannot_delegate_if_less_than_or_equal_lowest_bottom() {

8831

1

	ExtBuilder::default()

8832

1

		.with_balances(vec![

8833

1

			(1, 20),

8834

1

			(2, 10),

8835

1

			(3, 10),

8836

1

			(4, 10),

8837

1

			(5, 10),

8838

1

			(6, 10),

8839

1

			(7, 10),

8840

1

			(8, 10),

8841

1

			(9, 10),

8842

1

			(10, 10),

8843

1

			(11, 10),

8844

1

])

8845

1

		.with_candidates(vec![(1, 20)])

8846

1

		.with_delegations(vec![

8847

1

			(2, 1, 10),

8848

1

			(3, 1, 10),

8849

1

			(4, 1, 10),

8850

1

			(5, 1, 10),

8851

1

			(6, 1, 10),

8852

1

			(8, 1, 10),

8853

1

			(9, 1, 10),

8854

1

			(10, 1, 10),

8855

1

])

8856

1

		.build()

8857

1

		.execute_with(|| {

8858

1

			assert_noop!(

8859

1

				ParachainStaking::delegate_with_auto_compound(

8860

1

					RuntimeOrigin::signed(11),

8861

1

1,

8862

1

10,

8863

1

					Percent::from_percent(50),

8864

1

8,

8865

1

0,

8866

1

8867

1

),

8868

1

				Error::<Test>::CannotDelegateLessThanOrEqualToLowestBottomWhenFull

8869

1

);

8870

1

});

8871

1

8872

8873

#[test]

8874

1

fn test_delegate_with_auto_compound_can_delegate_if_greater_than_lowest_bottom() {

8875

1

	ExtBuilder::default()

8876

1

		.with_balances(vec![

8877

1

			(1, 20),

8878

1

			(2, 10),

8879

1

			(3, 10),

8880

1

			(4, 10),

8881

1

			(5, 10),

8882

1

			(6, 10),

8883

1

			(7, 10),

8884

1

			(8, 10),

8885

1

			(9, 10),

8886

1

			(10, 10),

8887

1

			(11, 11),

8888

1

])

8889

1

		.with_candidates(vec![(1, 20)])

8890

1

		.with_delegations(vec![

8891

1

			(2, 1, 10),

8892

1

			(3, 1, 10),

8893

1

			(4, 1, 10),

8894

1

			(5, 1, 10),

8895

1

			(6, 1, 10),

8896

1

			(8, 1, 10),

8897

1

			(9, 1, 10),

8898

1

			(10, 1, 10),

8899

1

])

8900

1

		.build()

8901

1

		.execute_with(|| {

8902

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8903

1

				RuntimeOrigin::signed(11),

8904

1

1,

8905

1

11,

8906

1

				Percent::from_percent(50),

8907

1

8,

8908

1

0,

8909

1

8910

1

));

8911

1

			assert_events_emitted!(Event::DelegationKicked {

8912

1

				delegator: 10,

8913

1

				candidate: 1,

8914

1

				unstaked_amount: 10

8915

1

});

8916

1

			assert_events_emitted!(Event::DelegatorLeft {

8917

1

				delegator: 10,

8918

1

				unstaked_amount: 10

8919

1

});

8920

1

});

8921

1

8922

8923

#[test]

8924

1

fn test_delegate_with_auto_compound_can_still_delegate_to_other_if_leaving() {

8925

1

	ExtBuilder::default()

8926

1

		.with_balances(vec![(1, 20), (2, 20), (3, 20)])

8927

1

		.with_candidates(vec![(1, 20), (3, 20)])

8928

1

		.with_delegations(vec![(2, 1, 10)])

8929

1

		.build()

8930

1

		.execute_with(|| {

8931

1

			assert_ok!(ParachainStaking::schedule_revoke_delegation(

8932

1

				RuntimeOrigin::signed(2),

8933

1

1,

8934

1

));

8935

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

8936

1

				RuntimeOrigin::signed(2),

8937

1

3,

8938

1

10,

8939

1

				Percent::from_percent(50),

8940

1

0,

8941

1

0,

8942

1

8943

1

			),);

8944

1

});

8945

1

8946

8947

#[test]

8948

1

fn test_delegate_with_auto_compound_cannot_delegate_if_candidate() {

8949

1

	ExtBuilder::default()

8950

1

		.with_balances(vec![(1, 20), (2, 30)])

8951

1

		.with_candidates(vec![(1, 20), (2, 20)])

8952

1

		.build()

8953

1

		.execute_with(|| {

8954

1

			assert_noop!(

8955

1

				ParachainStaking::delegate_with_auto_compound(

8956

1

					RuntimeOrigin::signed(2),

8957

1

1,

8958

1

10,

8959

1

					Percent::from_percent(50),

8960

1

0,

8961

1

0,

8962

1

8963

1

),

8964

1

				Error::<Test>::CandidateExists

8965

1

);

8966

1

});

8967

1

8968

8969

#[test]

8970

1

fn test_delegate_with_auto_compound_cannot_delegate_if_already_delegated() {

8971

1

	ExtBuilder::default()

8972

1

		.with_balances(vec![(1, 20), (2, 30)])

8973

1

		.with_candidates(vec![(1, 20)])

8974

1

		.with_delegations(vec![(2, 1, 20)])

8975

1

		.build()

8976

1

		.execute_with(|| {

8977

1

			assert_noop!(

8978

1

				ParachainStaking::delegate_with_auto_compound(

8979

1

					RuntimeOrigin::signed(2),

8980

1

1,

8981

1

10,

8982

1

					Percent::from_percent(50),

8983

1

0,

8984

1

1,

8985

1

8986

1

),

8987

1

				Error::<Test>::AlreadyDelegatedCandidate

8988

1

);

8989

1

});

8990

1

8991

8992

#[test]

8993

1

fn test_delegate_with_auto_compound_cannot_delegate_more_than_max_delegations() {

8994

1

	ExtBuilder::default()

8995

1

		.with_balances(vec![(1, 20), (2, 50), (3, 20), (4, 20), (5, 20), (6, 20)])

8996

1

		.with_candidates(vec![(1, 20), (3, 20), (4, 20), (5, 20), (6, 20)])

8997

1

		.with_delegations(vec![(2, 1, 10), (2, 3, 10), (2, 4, 10), (2, 5, 10)])

8998

1

		.build()

8999

1

		.execute_with(|| {

9000

1

			assert_noop!(

9001

1

				ParachainStaking::delegate_with_auto_compound(

9002

1

					RuntimeOrigin::signed(2),

9003

1

6,

9004

1

10,

9005

1

					Percent::from_percent(50),

9006

1

0,

9007

1

0,

9008

1

9009

1

),

9010

1

				Error::<Test>::ExceedMaxDelegationsPerDelegator,

9011

1

);

9012

1

});

9013

1

9014

9015

#[test]

9016

1

fn test_delegate_skips_auto_compound_storage_but_emits_event_for_zero_auto_compound() {

9017

1

	ExtBuilder::default()

9018

1

		.with_balances(vec![(1, 30), (2, 20), (3, 30)])

9019

1

		.with_candidates(vec![(1, 30)])

9020

1

		.with_auto_compounding_delegations(vec![(3, 1, 10, Percent::from_percent(50))])

9021

1

		.build()

9022

1

		.execute_with(|| {

9023

1

			// We already have an auto-compounding delegation from 3 -> 1, so the hint validation

9024

1

			// would cause a failure if the auto-compounding isn't skipped properly.

9025

1

			assert_ok!(ParachainStaking::delegate_with_auto_compound(

9026

1

				RuntimeOrigin::signed(2),

9027

1

1,

9028

1

10,

9029

1

				Percent::zero(),

9030

1

1,

9031

1

0,

9032

1

0,

9033

1

));

9034

1

			assert_eq!(1, ParachainStaking::auto_compounding_delegations(&1).len(),);

9035

1

			assert_events_eq!(Event::Delegation {

9036

1

				delegator: 2,

9037

1

				locked_amount: 10,

9038

1

				candidate: 1,

9039

1

				delegator_position: DelegatorAdded::AddedToTop { new_total: 50 },

9040

1

				auto_compound: Percent::zero(),

9041

1

});

9042

1

});

9043

1

9044

9045

#[test]

9046

1

fn test_on_initialize_weights() {

9047

	use crate::mock::System;

9048

	use crate::weights::{SubstrateWeight as PalletWeights, WeightInfo};

9049

	use crate::*;

9050

	use frame_support::{pallet_prelude::*, weights::constants::RocksDbWeight};

9051

9052

	// generate balance, candidate, and delegation vecs to "fill" out delegations

9053

1

	let mut balances = Vec::new();

9054

1

	let mut candidates = Vec::new();

9055

1

	let mut delegations = Vec::new();

9056

9057

30

	for collator in 1..30 {

9058

29

		balances.push((collator, 100));

9059

29

		candidates.push((collator, 10));

9060

29

		let starting_delegator = collator * 1000;

9061

8700

		for delegator in starting_delegator..starting_delegator + 300 {

9062

8700

			balances.push((delegator, 100));

9063

8700

			delegations.push((delegator, collator, 10));

9064

8700

9065

9066

9067

1

	ExtBuilder::default()

9068

1

		.with_balances(balances)

9069

1

		.with_candidates(candidates)

9070

1

		.with_delegations(delegations)

9071

1

		.build()

9072

1

		.execute_with(|| {

9073

1

			let weight = ParachainStaking::on_initialize(1);

9074

1

9075

1

			// TODO: build this with proper db reads/writes

9076

1

			assert_eq!(Weight::from_parts(401000000, 0), weight);

9077

9078

			// roll to the end of the round, then run on_init again, we should see round change...

9079

1

			set_author(3, 1, POINTS_PER_ROUND); // must set some points for prepare_staking_payouts

9080

1

			roll_to_round_end(3);

9081

1

			let block = System::block_number() + 1;

9082

1

			let weight = ParachainStaking::on_initialize(block);

9083

1

9084

1

			// the total on_init weight during our round change. this number is taken from running

9085

1

			// the fn with a given weights.rs benchmark, so will need to be updated as benchmarks

9086

1

			// change.

9087

1

//

9088

1

			// following this assertion, we add individual weights together to show that we can

9089

1

			// derive this number independently.

9090

1

			let expected_on_init = 2999210735;

9091

1

			assert_eq!(Weight::from_parts(expected_on_init, 51554), weight);

9092

9093

			// assemble weight manually to ensure it is well understood

9094

1

			let mut expected_weight = 0u64;

9095

1

			expected_weight += PalletWeights::<Test>::base_on_initialize().ref_time();

9096

1

			expected_weight += PalletWeights::<Test>::prepare_staking_payouts().ref_time();

9097

1

			expected_weight += PalletWeights::<Test>::mark_collators_as_inactive(5).ref_time();

9098

1

9099

1

			// TODO: this should be the same as <TotalSelected<Test>>. I believe this relates to

9100

1

			// genesis building

9101

1

			let num_avg_delegations = 8;

9102

1

			expected_weight += PalletWeights::<Test>::select_top_candidates(

9103

1

				<TotalSelected<Test>>::get(),

9104

1

				num_avg_delegations,

9105

1

9106

1

			.ref_time();

9107

1

			// SlotProvider read

9108

1

			expected_weight += RocksDbWeight::get().reads_writes(1, 0).ref_time();

9109

1

			// Round write, done in on-round-change code block inside on_initialize()

9110

1

			expected_weight += RocksDbWeight::get().reads_writes(0, 1).ref_time();

9111

1

			// more reads/writes manually accounted for for on_finalize

9112

1

			expected_weight += RocksDbWeight::get().reads_writes(4, 3).ref_time();

9113

1

9114

1

			assert_eq!(Weight::from_parts(expected_weight, 51554), weight);

9115

1

			assert_eq!(expected_on_init, expected_weight); // magic number == independent accounting

9116

1

});

9117

1

9118

9119

#[test]

9120

1

fn test_compute_top_candidates_is_stable() {

9121

1

	ExtBuilder::default()

9122

1

		.with_balances(vec![(1, 30), (2, 30), (3, 30), (4, 30), (5, 30), (6, 30)])

9123

1

		.with_candidates(vec![(1, 30), (2, 30), (3, 30), (4, 30), (5, 30), (6, 30)])

9124

1

		.build()

9125

1

		.execute_with(|| {

9126

1

			// There are 6 candidates with equal amount, but only 5 can be selected

9127

1

			assert_eq!(ParachainStaking::candidate_pool().0.len(), 6);

9128

1

			assert_eq!(ParachainStaking::total_selected(), 5);

9129

			// Returns the 5 candidates with greater AccountId, because they are iterated in reverse

9130

1

			assert_eq!(

9131

1

				ParachainStaking::compute_top_candidates(),

9132

1

				vec![2, 3, 4, 5, 6]

9133

1

);

9134

1

});

9135

1