return both overview and page

frame/staking/src/pallet/impls.rs

@@ -205,7 +205,7 @@ impl<T: Config> Pallet<T> {
 		// Then look at the validator, figure out the proportion of their reward
 		// which goes to them and each of their nominators.
 
-		let exposure = EraInfo::<T>::get_validator_exposure(era, &ledger.stash, page);
+		let (exposure_overview, exposure_page) = EraInfo::<T>::get_validator_exposure(era, &ledger.stash, page);
 		let era_reward_points = <ErasRewardPoints<T>>::get(&era);
 		let total_reward_points = era_reward_points.total;
 		let validator_reward_points = era_reward_points
@@ -232,7 +232,7 @@ impl<T: Config> Pallet<T> {
 
 		let validator_leftover_payout = validator_total_payout - validator_commission_payout;
 		// Now let's calculate how this is split to the validator.
-		let validator_exposure_part = Perbill::from_rational(exposure.own, exposure.total);
+		let validator_exposure_part = Perbill::from_rational(exposure_overview.own, exposure_overview.total);
 		let validator_staking_payout = validator_exposure_part * validator_leftover_payout;
 
 		Self::deposit_event(Event::<T>::PayoutStarted {
@@ -259,8 +259,8 @@ impl<T: Config> Pallet<T> {
 
 		// Lets now calculate how this is split to the nominators.
 		// Reward only the clipped exposures. Note this is not necessarily sorted.
-		for nominator in exposure.others.iter() {
-			let nominator_exposure_part = Perbill::from_rational(nominator.value, exposure.total);
+		for nominator in exposure_page.others.iter() {
+			let nominator_exposure_part = Perbill::from_rational(nominator.value, exposure_overview.total);
 
 			let nominator_reward: BalanceOf<T> =
 				nominator_exposure_part * validator_leftover_payout;

frame/staking/src/pallet/mod.rs

@@ -679,20 +679,40 @@ pub mod pallet {
 			era: EraIndex,
 			validator: &T::AccountId,
 			page: PageIndex,
-		) -> Exposure<T::AccountId, BalanceOf<T>> {
+		) -> (ExposureOverview<BalanceOf<T>>, ExposurePage<T::AccountId, BalanceOf<T>>) {
 			return match <ErasStakersPaged<T>>::get(era, (validator, page)) {
 				// only return clipped exposure if page zero and no paged exposure entry
-				None if page == 0 => <ErasStakersClipped<T>>::get(&era, validator),
+				None if page == 0 => Self::get_clipped_exposure_as_page(era, validator),
 				Some(exposure_page) => {
 					let overview = <ErasStakersOverview<T>>::get(&era, validator);
 					// own stake is included only once in the first page.
 					let own = if page == 0 { overview.own } else { Zero::zero() };
-					Exposure { total: overview.total, own, others: exposure_page.others }
+					(ExposureOverview {
+						own,
+						..overview
+					}, exposure_page)
 				},
 				_ => Default::default(),
 			}
 		}
 
+		/// Get clipped exposure and convert it as `ExposurePage`.
+		fn get_clipped_exposure_as_page(
+			era: EraIndex,
+			validator: &T::AccountId,
+		) -> (ExposureOverview<BalanceOf<T>>, ExposurePage<T::AccountId, BalanceOf<T>>) {
+			let exposure = <ErasStakersClipped<T>>::get(&era, validator);
+			(
+				ExposureOverview {
+					total: exposure.total,
+					own: exposure.own,
+					nominator_count: exposure.others.len() as u32,
+					page_count: 1,
+				},
+				ExposurePage { page_total: exposure.total, others: exposure.others },
+			)
+		}
+
 		/// Returns the number of pages of exposure a validator has for the given era.
 		///
 		/// This will always return at minimum one count of exposure to be backward compatible to
@@ -785,8 +805,7 @@ pub mod pallet {
 				.unwrap_or_else(|| T::MaxExposurePageSize::get())
 				.clamp(1, T::MaxExposurePageSize::get());
 
-			let (exposure_overview, exposure_pages) =
-				exposure.into_pages(page_size);
+			let (exposure_overview, exposure_pages) = exposure.into_pages(page_size);
 
 			<ErasStakersOverview<T>>::insert(era, &validator, &exposure_overview);
 			exposure_pages.iter().enumerate().for_each(|(page, paged_exposure)| {

frame/staking/src/tests.rs

@@ -3770,14 +3770,14 @@ fn test_multi_page_payout_stakers_by_page() {
 
 		// verify the exposures are calculated correctly.
 		let actual_exposure_0 = EraInfo::<Test>::get_validator_exposure(1, &11, 0);
-		assert_eq!(actual_exposure_0.total, total_exposure);
-		assert_eq!(actual_exposure_0.own, 1000);
-		assert_eq!(actual_exposure_0.others.len(), 64);
+		assert_eq!(actual_exposure_0.0.total, total_exposure);
+		assert_eq!(actual_exposure_0.0.own, 1000);
+		assert_eq!(actual_exposure_0.1.others.len(), 64);
 		let actual_exposure_1 = EraInfo::<Test>::get_validator_exposure(1, &11, 1);
-		assert_eq!(actual_exposure_1.total, total_exposure);
+		assert_eq!(actual_exposure_1.0.total, total_exposure);
 		// own stake is only included once in the first page
-		assert_eq!(actual_exposure_1.own, 0);
-		assert_eq!(actual_exposure_1.others.len(), 100 - 64);
+		assert_eq!(actual_exposure_1.0.own, 0);
+		assert_eq!(actual_exposure_1.1.others.len(), 100 - 64);
 
 		let pre_payout_total_issuance = Balances::total_issuance();
 		RewardOnUnbalanceWasCalled::set(false);
@@ -3901,11 +3901,21 @@ fn test_multi_page_payout_stakers_by_page() {
 		assert_eq!(Staking::claimed_rewards(first_claimable_reward_era, &11), vec![0, 1]);
 
 		// verify only page 0 is marked as claimed
-		assert_ok!(Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, last_reward_era, 0));
+		assert_ok!(Staking::payout_stakers_by_page(
+			RuntimeOrigin::signed(1337),
+			11,
+			last_reward_era,
+			0
+		));
 		assert_eq!(Staking::claimed_rewards(last_reward_era, &11), vec![0]);
 
 		// verify page 0 and 1 are marked as claimed
-		assert_ok!(Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, last_reward_era, 1));
+		assert_ok!(Staking::payout_stakers_by_page(
+			RuntimeOrigin::signed(1337),
+			11,
+			last_reward_era,
+			1
+		));
 		assert_eq!(Staking::claimed_rewards(last_reward_era, &11), vec![0, 1]);
 
 		// Out of order claims works.
@@ -4009,23 +4019,43 @@ fn payout_stakers_handles_basic_errors() {
 
 		// Can't claim again
 		assert_noop!(
-			Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, expected_start_reward_era, 0),
+			Staking::payout_stakers_by_page(
+				RuntimeOrigin::signed(1337),
+				11,
+				expected_start_reward_era,
+				0
+			),
 			Error::<Test>::AlreadyClaimed.with_weight(err_weight)
 		);
 
 		assert_noop!(
-			Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, expected_last_reward_era, 0),
+			Staking::payout_stakers_by_page(
+				RuntimeOrigin::signed(1337),
+				11,
+				expected_last_reward_era,
+				0
+			),
 			Error::<Test>::AlreadyClaimed.with_weight(err_weight)
 		);
 
 		assert_noop!(
-			Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, expected_last_reward_era, 1),
+			Staking::payout_stakers_by_page(
+				RuntimeOrigin::signed(1337),
+				11,
+				expected_last_reward_era,
+				1
+			),
 			Error::<Test>::AlreadyClaimed.with_weight(err_weight)
 		);
 
 		// invalid page
 		assert_noop!(
-			Staking::payout_stakers_by_page(RuntimeOrigin::signed(1337), 11, expected_last_reward_era, 2),
+			Staking::payout_stakers_by_page(
+				RuntimeOrigin::signed(1337),
+				11,
+				expected_last_reward_era,
+				2
+			),
 			Error::<Test>::InvalidPage.with_weight(err_weight)
 		);
 	});
@@ -4123,8 +4153,11 @@ fn payout_stakers_handles_weight_refund() {
 		start_active_era(2);
 
 		// Collect payouts when there are no nominators
-		let call =
-			TestCall::Staking(StakingCall::payout_stakers_by_page { validator_stash: 11, era: 1, page: 0 });
+		let call = TestCall::Staking(StakingCall::payout_stakers_by_page {
+			validator_stash: 11,
+			era: 1,
+			page: 0,
+		});
 		let info = call.get_dispatch_info();
 		let result = call.dispatch(RuntimeOrigin::signed(20));
 		assert_ok!(result);
@@ -4137,8 +4170,11 @@ fn payout_stakers_handles_weight_refund() {
 		start_active_era(3);
 
 		// Collect payouts for an era where the validator did not receive any points.
-		let call =
-			TestCall::Staking(StakingCall::payout_stakers_by_page { validator_stash: 11, era: 2, page: 0 });
+		let call = TestCall::Staking(StakingCall::payout_stakers_by_page {
+			validator_stash: 11,
+			era: 2,
+			page: 0,
+		});
 		let info = call.get_dispatch_info();
 		let result = call.dispatch(RuntimeOrigin::signed(20));
 		assert_ok!(result);
@@ -4151,8 +4187,11 @@ fn payout_stakers_handles_weight_refund() {
 		start_active_era(4);
 
 		// Collect payouts when the validator has `half_max_nom_rewarded` nominators.
-		let call =
-			TestCall::Staking(StakingCall::payout_stakers_by_page { validator_stash: 11, era: 3, page: 0 });
+		let call = TestCall::Staking(StakingCall::payout_stakers_by_page {
+			validator_stash: 11,
+			era: 3,
+			page: 0,
+		});
 		let info = call.get_dispatch_info();
 		let result = call.dispatch(RuntimeOrigin::signed(20));
 		assert_ok!(result);
@@ -4175,16 +4214,22 @@ fn payout_stakers_handles_weight_refund() {
 		start_active_era(6);
 
 		// Collect payouts when the validator had `half_max_nom_rewarded` nominators.
-		let call =
-			TestCall::Staking(StakingCall::payout_stakers_by_page { validator_stash: 11, era: 5, page: 0 });
+		let call = TestCall::Staking(StakingCall::payout_stakers_by_page {
+			validator_stash: 11,
+			era: 5,
+			page: 0,
+		});
 		let info = call.get_dispatch_info();
 		let result = call.dispatch(RuntimeOrigin::signed(20));
 		assert_ok!(result);
 		assert_eq!(extract_actual_weight(&result, &info), max_nom_rewarded_weight);
 
 		// Try and collect payouts for an era that has already been collected.
-		let call =
-			TestCall::Staking(StakingCall::payout_stakers_by_page { validator_stash: 11, era: 5, page: 0 });
+		let call = TestCall::Staking(StakingCall::payout_stakers_by_page {
+			validator_stash: 11,
+			era: 5,
+			page: 0,
+		});
 		let info = call.get_dispatch_info();
 		let result = call.dispatch(RuntimeOrigin::signed(20));
 		assert!(result.is_err());
@@ -5980,11 +6025,11 @@ fn test_validator_exposure_is_backward_compatible_with_non_paged_rewards_payout(
 		);
 		// verify `EraInfo` returns page from paged storage
 		assert_eq!(
-			EraInfo::<Test>::get_validator_exposure(1, &11, 0).others,
+			EraInfo::<Test>::get_validator_exposure(1, &11, 0).1.others,
 			actual_exposure_page_0.others
 		);
 		assert_eq!(
-			EraInfo::<Test>::get_validator_exposure(1, &11, 1).others,
+			EraInfo::<Test>::get_validator_exposure(1, &11, 1).1.others,
 			actual_exposure_page_1.others
 		);
 		assert_eq!(EraInfo::<Test>::get_page_count(1, &11), 2);
@@ -6006,11 +6051,14 @@ fn test_validator_exposure_is_backward_compatible_with_non_paged_rewards_payout(
 		// verify `EraInfo` returns exposure from clipped storage
 		assert!(matches!(
 			EraInfo::<Test>::get_validator_exposure(1, &11, 0),
-			Exposure {
+			(ExposureOverview {
 				own,
+				page_count,
+				..
+			}, ExposurePage {
 				others,
 				..
-			} if others == clipped_exposure && own == 1000));
+			}) if others == clipped_exposure && own == 1000 && page_count == 1));
 
 		// for pages other than 0, clipped storage returns empty exposure
 		assert_eq!(EraInfo::<Test>::get_validator_exposure(1, &11, 1), Default::default());