Staking Complete Analysis

// Main dependencies
use frame_election_provider_support::{ElectionProvider, ElectionProviderBase, SortedListProvider, VoteWeight};
use frame_support::{pallet_prelude::*, traits::{Currency, Defensive, EnsureOrigin, ...}};
use sp_staking::{EraIndex, SessionIndex, StakingAccount};

pub type Bonded = StorageMap<_, Twox64Concat, T::AccountId, T::AccountId>;
pub type Ledger = StorageMap<_, Blake2_128Concat, T::AccountId, StakingLedger>;
pub type Payee = StorageMap<_, Twox64Concat, T::AccountId, RewardDestination>;

pub type Validators = CountedStorageMap<_, Twox64Concat, T::AccountId, ValidatorPrefs>;
pub type Nominators = CountedStorageMap<_, Twox64Concat, T::AccountId, Nominations>;

pub type CurrentEra = StorageValue<_, EraIndex>;
pub type ActiveEra = StorageValue<_, ActiveEraInfo>;
pub type ErasStakers = StorageDoubleMap<_, Twox64Concat, EraIndex, Twox64Concat, T::AccountId, Exposure>>;

pub struct StakingLedger {
    pub stash: T::AccountId,           // Stash account
    pub total: BalanceOf,          // Total balance
    pub active: BalanceOf,         // Active balance
    pub unlocking: BoundedVec>, T::MaxUnlockingChunks>,
    pub claimed_rewards: BoundedVec,
    pub vivid_staking: Option,
    pub controller: Option,
}

pub struct Exposure {
    pub total: Balance,                // Total exposure
    pub own: Balance,                  // Own exposure
    pub others: Vec>,
    pub vivid_staking: Option,
}

pub fn ledger(account: StakingAccount) -> Result, Error> {
    StakingLedger::::get(account)
}

pub fn bonded(stash: &T::AccountId) -> Option {
    StakingLedger::::paired_account(Stash(stash.clone()))
}

fn calculate_interest(era: EraIndex, opt_vivid_staking: &Option) -> Perbill {
    if let Some(vivid_staking) = opt_vivid_staking {
        if vivid_staking.starting_era <= era && vivid_staking.ending_era >= era {
            let eras_count = vivid_staking.ending_era.saturating_sub(vivid_staking.starting_era.saturating_sub(1));
            let months_count = eras_count / 28;
            return T::StandartStakingInterest::get() + 
                   Perbill::from_parts(T::VividStakingInterestPerMonth::get().deconstruct() * months_count);
        }
    }
    T::StandartStakingInterest::get()
}

pub(super) fn do_payout_stakers(
    validator_stash: T::AccountId,
    era: EraIndex,
) -> DispatchResultWithPostInfo {
    // Era validation
    let current_era = CurrentEra::::get().ok_or_else(|| {
        Error::::InvalidEraToReward.with_weight(T::WeightInfo::payout_stakers_alive_staked(0))
    })?;
    
    // Get ledger and check for already claimed rewards
    let mut ledger = Self::ledger(account.clone())?;
    match ledger.claimed_rewards.binary_search(&era) {
        Ok(_) => return Err(Error::::AlreadyClaimed),
        Err(pos) => ledger.claimed_rewards.try_insert(pos, era)?,
    }
    
    // Get era exposure
    let exposure = >::get(&era, &stash);
    
    // Calculate rewards for nominators
    for nominator in exposure.others.iter() {
        let interest = Self::calculate_interest(era, &nominator.vivid_staking);
        let mut nominator_reward: BalanceOf = portion * interest * nominator.value;
        
        // Deduct validator commission
        validator_payment_commissions += validator_commission * nominator_reward;
        nominator_reward -= validator_commission * nominator_reward;
        
        // Create payout
        if let Some((imbalance, dest)) = Self::make_payout(&nominator.who, nominator_reward) {
            nominator_payout_count += 1;
            Self::deposit_event(Event::::Rewarded {
                stash: nominator.who.clone(),
                dest,
                amount: imbalance.peek(),
            });
            total_imbalance.subsume(imbalance);
        }
    }
    
    // Calculate rewards for validator
    let validator_own_interest = Self::calculate_interest(era, &exposure.vivid_staking);
    let validator_own_reward = portion * validator_own_interest * exposure.own;
    let validator_reward = validator_own_reward + validator_payment_commissions;
    
    // Payout to validator
    if let Some((imbalance, dest)) = Self::make_payout(&stash, validator_reward) {
        Self::deposit_event(Event::::Rewarded {
            stash: stash.clone(),
            dest,
            amount: imbalance.peek(),
        });
        total_imbalance.subsume(imbalance);
    }
    
    T::Reward::on_unbalanced(total_imbalance);
    Ok(Some(T::WeightInfo::payout_stakers_alive_staked(nominator_payout_count)).into())
}

pub fn get_npos_voters(bounds: DataProviderBounds) -> Vec> {
    let mut voters_size_tracker: StaticTracker = StaticTracker::default();
    let final_predicted_len = {
        let all_voter_count = T::VoterList::count();
        bounds.count.unwrap_or(all_voter_count.into()).min(all_voter_count.into()).0
    };
    
    let mut all_voters = Vec::<_>::with_capacity(final_predicted_len as usize);
    let weight_of = Self::weight_of_fn();
    
    let mut voters_seen = 0u32;
    let mut validators_taken = 0u32;
    let mut nominators_taken = 0u32;
    let mut min_active_stake = u64::MAX;
    
    let mut sorted_voters = T::VoterList::iter();
    while all_voters.len() < final_predicted_len as usize
        && voters_seen < (NPOS_MAX_ITERATIONS_COEFFICIENT * final_predicted_len as u32)
    {
        let voter = match sorted_voters.next() {
            Some(voter) => {
                voters_seen.saturating_inc();
                voter
            },
            None => break,
        };
        
        let voter_weight = weight_of(&voter);
        if voter_weight.is_zero() {
            continue;
        }
        
        if let Some(Nominations { targets, .. }) = >::get(&voter) {
            if !targets.is_empty() {
                let voter = (voter, voter_weight, targets);
                if voters_size_tracker.try_register_voter(&voter, &bounds).is_err() {
                    Self::deposit_event(Event::::SnapshotVotersSizeExceeded {
                        size: voters_size_tracker.size as u32,
                    });
                    break;
                }
                all_voters.push(voter);
                nominators_taken.saturating_inc();
            }
        } else if Validators::::contains_key(&voter) {
            let self_vote = (
                voter.clone(),
                voter_weight,
                vec![voter.clone()].try_into().expect("MaxVotesPerVoter must be >= 1"),
            );
            
            if voters_size_tracker.try_register_voter(&self_vote, &bounds).is_err() {
                Self::deposit_event(Event::::SnapshotVotersSizeExceeded {
                    size: voters_size_tracker.size as u32,
                });
                break;
            }
            all_voters.push(self_vote);
            validators_taken.saturating_inc();
        }
        
        min_active_stake = if voter_weight < min_active_stake { voter_weight } else { min_active_stake };
    }
    
    MinimumActiveStake::::put(min_active_stake);
    all_voters
}

impl pallet_session::SessionManager for Pallet {
    fn new_session(new_index: SessionIndex) -> Option> {
        log!(trace, "planning new session {}", new_index);
        CurrentPlannedSession::::put(new_index);
        Self::new_session(new_index, false).map(|v| v.into_inner())
    }
    
    fn start_session(start_index: SessionIndex) {
        log!(trace, "starting session {}", start_index);
        Self::start_session(start_index)
    }
    
    fn end_session(end_index: SessionIndex) {
        log!(trace, "ending session {}", end_index);
        Self::end_session(end_index)
    }
}

pub fn api_nominations_quota(balance: BalanceOf) -> u32 {
    T::NominationsQuota::get_quota(balance)
}

pub fn api_estimate_staking_payout(account: T::AccountId) -> BalanceOf {
    let Some(active_era) = Self::active_era() else { return Zero::zero() };
    
    let era_duration: u64 = T::SessionsPerEra::get()
        .saturating_mul(T::NextNewSession::average_session_length().saturated_into())
        .saturating_mul(T::ExpectedBlockTime::get().saturated_into())
        .try_into().unwrap_or(0);
    
    let portion = Perbill::from_rational(era_duration, MILLISECONDS_PER_YEAR);
    
    let Some(Nominations { targets, .. }) = Self::nominators(&account) else {
        return Zero::zero();
    };
    
    targets.iter().fold(Zero::zero(), |acc, validator| {
        let exposure = Self::eras_stakers_clipped(active_era.index, validator);
        let Some(nominator_exposure) = exposure.others.iter().find(|&x| x.who == account) else {
            return acc;
        };
        
        let validator_prefs = Self::eras_validator_prefs(&active_era.index, &validator);
        let interest = Self::calculate_interest(active_era.index, &nominator_exposure.vivid_staking);
        
        let nominator_reward: BalanceOf = portion
            * interest * Perbill::one()
            .saturating_sub(validator_prefs.commission)
            * nominator_exposure.value;
        
        acc + nominator_reward
    })
}