Merge pull request #3711 from autonomys/offline_operator_detection

Offline operator detection

Author: vedhavyas

Cargo.lock

@@ -206,7 +206,7 @@ serde_json = "1.0.133"
 sha2 = { version = "0.10.7", default-features = false }
 sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "e831132867930ca90a7088c7246301ab29f015ba", default-features = false }
 sp-application-crypto = { git = "https://github.com/subspace/polkadot-sdk", rev = "e831132867930ca90a7088c7246301ab29f015ba", default-features = false }
-sp-arithmetic = { git = "https://github.com/subspace/polkadot-sdk", rev = "e831132867930ca90a7088c7246301ab29f015ba" }
+sp-arithmetic = { git = "https://github.com/subspace/polkadot-sdk", rev = "e831132867930ca90a7088c7246301ab29f015ba", default-features = false }
 sp-auto-id = { version = "0.1.0", path = "domains/primitives/auto-id", default-features = false }
 sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "e831132867930ca90a7088c7246301ab29f015ba", default-features = false }
 sp-block-fees = { version = "0.1.0", path = "domains/primitives/block-fees", default-features = false }

Cargo.toml

@@ -97,11 +97,15 @@ pub trait HoldIdentifier<T: Config> {
 }
 
 pub trait BlockSlot<T: frame_system::Config> {
-    // Return the future slot of the given `block_number`
+    /// Returns the highest valid slot for the given `block_number`.
+    /// Returns `None` if that block number is too far in the past, or too far in the future.
     fn future_slot(block_number: BlockNumberFor<T>) -> Option<sp_consensus_slots::Slot>;
 
-    // Return the latest block number whose slot is less than the given `to_check` slot
+    /// Returns the latest block number whose slot is less than the given `to_check` slot
     fn slot_produced_after(to_check: sp_consensus_slots::Slot) -> Option<BlockNumberFor<T>>;
+
+    /// Returns the slot at the current block height
+    fn current_slot() -> sp_consensus_slots::Slot;
 }
 
 pub type ExecutionReceiptOf<T> = ExecutionReceipt<
@@ -281,9 +285,11 @@ mod pallet {
     use frame_support::{Identity, PalletError};
     use frame_system::pallet_prelude::*;
     use parity_scale_codec::FullCodec;
+    use sp_consensus_slots::Slot;
     use sp_core::H256;
     use sp_domains::bundle::BundleDigest;
     use sp_domains::bundle_producer_election::ProofOfElectionError;
+    use sp_domains::offline_operators::OperatorEpochExpectations;
     use sp_domains::{
         BundleAndExecutionReceiptVersion, DomainBundleSubmitted, DomainId, DomainOwner,
         DomainSudoCall, DomainsTransfersTracker, EpochIndex,
@@ -816,6 +822,15 @@ mod pallet {
     pub type PreviousBundleAndExecutionReceiptVersions<T> =
         StorageValue<_, BTreeMap<BlockNumberFor<T>, BundleAndExecutionReceiptVersion>, ValueQuery>;
 
+    /// Stores the slot at which a new epoch has started.
+    #[pallet::storage]
+    pub type EpochStartSlot<T> = StorageValue<_, Slot, OptionQuery>;
+
+    /// Stores the number of bundles each operator submitted in a given epoch.
+    /// Storage is cleared at the end of epoch.
+    #[pallet::storage]
+    pub type OperatorBundleCountInEpoch<T> = StorageMap<_, Identity, OperatorId, u64, ValueQuery>;
+
     #[derive(TypeInfo, Encode, Decode, PalletError, Debug, PartialEq)]
     pub enum BundleError {
         /// Can not find the operator for given operator id.
@@ -1140,6 +1155,12 @@ mod pallet {
             operator_id: OperatorId,
             domain_id: DomainId,
         },
+        OperatorOffline {
+            operator_id: OperatorId,
+            domain_id: DomainId,
+            submitted_bundles: u64,
+            expectations: OperatorEpochExpectations,
+        },
     }
 
     #[pallet::origin]
@@ -1192,6 +1213,9 @@ mod pallet {
             #[cfg_attr(feature = "runtime-benchmarks", allow(unused_variables))]
             let receipt_block_number = *receipt.domain_block_number();
 
+            // increment the operator bundle count in the epoch.
+            OperatorBundleCountInEpoch::<T>::mutate(operator_id, |c| c.saturating_add(1));
+
             #[cfg(not(feature = "runtime-benchmarks"))]
             let mut actual_weight = T::WeightInfo::submit_bundle();
             #[cfg(feature = "runtime-benchmarks")]

crates/pallet-domains/src/lib.rs

@@ -1,17 +1,19 @@
 //! Staking epoch transition for domain
 use crate::bundle_storage_fund::deposit_reserve_for_storage_fund;
 use crate::pallet::{
-    AccumulatedTreasuryFunds, Deposits, DomainStakingSummary, LastEpochStakingDistribution,
-    OperatorIdOwner, Operators, PendingSlashes, PendingStakingOperationCount, Withdrawals,
+    AccumulatedTreasuryFunds, Deposits, DomainRegistry, DomainStakingSummary,
+    LastEpochStakingDistribution, OperatorIdOwner, Operators, PendingSlashes,
+    PendingStakingOperationCount, Withdrawals,
 };
 use crate::staking::{
     DomainEpoch, Error as TransitionError, OperatorStatus, SharePrice, WithdrawalInShares,
     do_cleanup_operator, do_convert_previous_epoch_deposits, do_convert_previous_epoch_withdrawal,
 };
 use crate::{
-    BalanceOf, Config, DeactivatedOperators, DepositOnHold, DeregisteredOperators,
-    DomainChainRewards, ElectionVerificationParams, Event, HoldIdentifier, InvalidBundleAuthors,
-    OperatorEpochSharePrice, Pallet, bundle_storage_fund,
+    BalanceOf, BlockSlot, Config, DeactivatedOperators, DepositOnHold, DeregisteredOperators,
+    DomainChainRewards, ElectionVerificationParams, EpochStartSlot, Event, HoldIdentifier,
+    InvalidBundleAuthors, OperatorBundleCountInEpoch, OperatorEpochSharePrice, Pallet,
+    bundle_storage_fund,
 };
 use frame_support::traits::fungible::{Inspect, Mutate, MutateHold};
 use frame_support::traits::tokens::{
@@ -21,9 +23,12 @@ use frame_support::{PalletError, StorageDoubleMap};
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_core::Get;
+use sp_domains::offline_operators::{
+    E_BASE, LN_1_OVER_TAU_1_PERCENT, operator_expected_bundles_in_epoch,
+};
 use sp_domains::{DomainId, EpochIndex, OperatorId, OperatorRewardSource};
 use sp_runtime::traits::{CheckedAdd, CheckedSub, One, Zero};
-use sp_runtime::{Perquintill, Saturating};
+use sp_runtime::{Perquintill, SaturatedConversion, Saturating};
 use sp_std::collections::btree_map::BTreeMap;
 use sp_std::collections::btree_set::BTreeSet;
 
@@ -237,6 +242,17 @@ pub(crate) fn do_finalize_domain_epoch_staking<T: Config>(
         let mut total_domain_stake = BalanceOf::<T>::zero();
         let mut current_operators = BTreeMap::new();
         let mut next_operators = BTreeSet::new();
+        let current_slot = T::BlockSlot::current_slot();
+        let total_epoch_slots = EpochStartSlot::<T>::get()
+            .map(|start_slot| current_slot - start_slot + 1)
+            .unwrap_or_default();
+        let epoch_total_stake = stake_summary.current_total_stake;
+        let operators_total_bundle_count =
+            OperatorBundleCountInEpoch::<T>::drain().collect::<BTreeMap<_, _>>();
+        let bundle_slot_probability = DomainRegistry::<T>::get(domain_id)
+            .ok_or(TransitionError::DomainNotInitialized)?
+            .domain_config
+            .bundle_slot_probability;
         for next_operator_id in &stake_summary.next_operators {
             // If an operator is pending to slash then similar to the slashed operator it should not be added
             // into the `next_operators/current_operators` and we should not `do_finalize_operator_epoch_staking`
@@ -245,6 +261,32 @@ pub(crate) fn do_finalize_domain_epoch_staking<T: Config>(
                 continue;
             }
 
+            // check operator performance in the previous epoch if the operator was part of the previous epoch set
+            // if they are not part of the previous epoch set, their performance will be checked in the next epoch.
+            if let Some(operator_stake) = stake_summary.current_operators.get(next_operator_id)
+                && let Some(bundle_count) = operators_total_bundle_count.get(next_operator_id)
+            {
+                let maybe_operator_epoch_expectations = operator_expected_bundles_in_epoch(
+                    total_epoch_slots.into(),
+                    (*operator_stake).saturated_into(),
+                    epoch_total_stake.saturated_into(),
+                    bundle_slot_probability,
+                    LN_1_OVER_TAU_1_PERCENT,
+                    E_BASE,
+                );
+
+                if let Some(operator_epoch_expectations) = maybe_operator_epoch_expectations
+                    && bundle_count < &operator_epoch_expectations.min_required_bundles
+                {
+                    Pallet::<T>::deposit_event(Event::OperatorOffline {
+                        operator_id: *next_operator_id,
+                        domain_id,
+                        submitted_bundles: *bundle_count,
+                        expectations: operator_epoch_expectations,
+                    });
+                };
+            }
+
             let (operator_stake, stake_changed) = do_finalize_operator_epoch_staking::<T>(
                 domain_id,
                 *next_operator_id,
@@ -263,6 +305,9 @@ pub(crate) fn do_finalize_domain_epoch_staking<T: Config>(
             }
         }
 
+        // set epoch start slot
+        EpochStartSlot::<T>::put(current_slot);
+
         // we finalized the operators who are in the next operator set.
         // But there will be deposits/withdrawals for operators who are not part of the next operator set.
         // So they need to have share price for the previous epoch

crates/pallet-domains/src/staking_epoch.rs

@@ -217,13 +217,17 @@ impl StorageFee<Balance> for DummyStorageFee {
 pub struct DummyBlockSlot;
 
 impl BlockSlot<Test> for DummyBlockSlot {
-    fn future_slot(_block_number: BlockNumberFor<Test>) -> Option<sp_consensus_slots::Slot> {
+    fn future_slot(_block_number: BlockNumberFor<Test>) -> Option<Slot> {
         None
     }
 
     fn slot_produced_after(_slot: sp_consensus_slots::Slot) -> Option<BlockNumberFor<Test>> {
         Some(0u32)
     }
+
+    fn current_slot() -> Slot {
+        Slot::from(0)
+    }
 }
 
 pub struct MockDomainsTransfersTracker;