ensure to create share price when operator de-registers

Author: vedhavyas

crates/pallet-domains/src/lib.rs

@@ -771,6 +771,12 @@ mod pallet {
     pub type InvalidBundleAuthors<T: Config> =
         StorageMap<_, Identity, DomainId, BTreeSet<OperatorId>, ValueQuery>;
 
+    /// Storage for operators who de-registered in the current epoch.
+    /// Will be cleared once epoch is transitioned.
+    #[pallet::storage]
+    pub type DeregisteredOperators<T: Config> =
+        StorageMap<_, Identity, DomainId, BTreeSet<OperatorId>, ValueQuery>;
+
     /// Storage that hold a previous versions of Bundle and Execution Receipt.
     /// Unfortunately, it adds a new item for every runtime upgrade if the versions change between
     /// runtime upgrades. If the versions does not change, then same version is set with higher block

crates/pallet-domains/src/staking.rs

@@ -11,9 +11,9 @@ use crate::pallet::{
 };
 use crate::staking_epoch::{mint_funds, mint_into_treasury};
 use crate::{
-    BalanceOf, Config, DepositOnHold, DomainBlockNumberFor, DomainHashingFor, Event,
-    ExecutionReceiptOf, HoldIdentifier, InvalidBundleAuthors, NominatorId, OperatorEpochSharePrice,
-    OperatorHighestSlot, Pallet, ReceiptHashFor, SlashedReason,
+    BalanceOf, Config, DepositOnHold, DeregisteredOperators, DomainBlockNumberFor,
+    DomainHashingFor, Event, ExecutionReceiptOf, HoldIdentifier, InvalidBundleAuthors, NominatorId,
+    OperatorEpochSharePrice, OperatorHighestSlot, Pallet, ReceiptHashFor, SlashedReason,
 };
 use frame_support::traits::fungible::{Inspect, MutateHold};
 use frame_support::traits::tokens::{Fortitude, Precision, Preservation};
@@ -690,6 +690,10 @@ pub(crate) fn do_deregister_operator<T: Config>(
                 operator.update_status(OperatorStatus::Deregistered(operator_deregister_info));
 
                 stake_summary.next_operators.remove(&operator_id);
+
+                DeregisteredOperators::<T>::mutate(operator.current_domain_id, |operators| {
+                    operators.insert(operator_id)
+                });
                 Ok(())
             },
         )
@@ -1123,36 +1127,35 @@ pub(crate) fn do_unlock_nominator<T: Config>(
         let mut deposit = Deposits::<T>::take(operator_id, nominator_id.clone())
             .ok_or(Error::UnknownNominator)?;
 
-        // convert any deposits from the previous epoch to shares
-        match do_convert_previous_epoch_deposits::<T>(
+        // convert any deposits from the previous epoch to shares.
+        // share prices will always be present because
+        // - if there are any deposits before operator de-registered, we ensure to create a
+        //   share price for them at the time of epoch transition.
+        // - if the operator got rewarded after the being de-registered and due to nomination tax
+        //   operator self deposits said tax amount, we calculate share price at the time of epoch transition.
+        do_convert_previous_epoch_deposits::<T>(
             operator_id,
             &mut deposit,
             current_domain_epoch_index,
-        ) {
-            // Share price may be missing if there is deposit happen in the same epoch as de-register
-            Ok(()) | Err(Error::MissingOperatorEpochSharePrice) => {}
-            Err(err) => return Err(err),
-        }
+        )?;
 
         // if there are any withdrawals from this operator, account for them
         // if the withdrawals has share price noted, then convert them to AI3
-        // if no share price, then it must be initiated in the epoch before operator de-registered,
-        // so get the shares as is and include them in the total staked shares.
         let (
             amount_ready_to_withdraw,
             total_storage_fee_withdrawal,
             shares_withdrew_in_current_epoch,
         ) = Withdrawals::<T>::take(operator_id, nominator_id.clone())
             .map(|mut withdrawal| {
-                match do_convert_previous_epoch_withdrawal::<T>(
+                // convert any withdrawals from the previous epoch to stake.
+                // share prices will always be present because
+                // - if there are any withdrawals before operator de-registered, we ensure to create a
+                //   share price for them at the time of epoch transition.
+                do_convert_previous_epoch_withdrawal::<T>(
                     operator_id,
                     &mut withdrawal,
                     current_domain_epoch_index,
-                ) {
-                    // Share price may be missing if there is withdrawal happen in the same epoch as de-register
-                    Ok(()) | Err(Error::MissingOperatorEpochSharePrice) => {}
-                    Err(err) => return Err(err),
-                }
+                )?;
                 Ok((
                     withdrawal.total_withdrawal_amount,
                     withdrawal.total_storage_fee_withdrawal,

crates/pallet-domains/src/staking_epoch.rs

@@ -9,8 +9,9 @@ use crate::staking::{
     do_cleanup_operator, do_convert_previous_epoch_deposits, do_convert_previous_epoch_withdrawal,
 };
 use crate::{
-    BalanceOf, Config, DepositOnHold, DomainChainRewards, ElectionVerificationParams, Event,
-    HoldIdentifier, InvalidBundleAuthors, OperatorEpochSharePrice, Pallet, bundle_storage_fund,
+    BalanceOf, Config, DepositOnHold, DeregisteredOperators, DomainChainRewards,
+    ElectionVerificationParams, Event, HoldIdentifier, InvalidBundleAuthors,
+    OperatorEpochSharePrice, Pallet, bundle_storage_fund,
 };
 use frame_support::traits::fungible::{Inspect, Mutate, MutateHold};
 use frame_support::traits::tokens::{
@@ -271,6 +272,8 @@ pub(crate) fn do_finalize_domain_epoch_staking<T: Config>(
         let mut operators_to_calculate_share_price = operators_with_self_deposits;
         // include invalid bundle authors
         operators_to_calculate_share_price.extend(InvalidBundleAuthors::<T>::take(domain_id));
+        // include operators who de-registered in this epoch
+        operators_to_calculate_share_price.extend(DeregisteredOperators::<T>::take(domain_id));
         // exclude operators who have already been processed as they are in next operator set.
         operators_to_calculate_share_price.retain(|&x| !stake_summary.next_operators.contains(&x));
 
@@ -785,8 +788,8 @@ mod tests {
             vec![(2, 10 * AI3), (4, 10 * AI3)],
             vec![(1, 20 * AI3), (2, 10 * AI3)],
             vec![
-                (1, 164285714285714285666),
-                (2, 64761904761904761888),
+                (1, 164285714285714285665),
+                (2, 64761904761904761879),
                 (3, 10952380952380952377),
                 (4, 10 * AI3),
             ],