feat: add consensus mode selection for liquid alpha calculations

Introduces ConsensusMode enum (Current/Previous/Auto) with per-subnet
storage LiquidAlphaConsensusMode<T> to control which consensus values
are used when computing liquid alpha bonding matrices.

- Auto (default): uses Previous when bond_penalty==1, else Current
- Current: always uses fresh in-memory consensus values
- Previous: always uses previous epoch consensus from storage (normalized)

Adds do_set_liquid_alpha_consensus_mode callable by subnet owner or root.

Author: ppolewicz

pallets/subtensor/src/epoch/run_epoch.rs

@@ -1286,9 +1286,21 @@ impl<T: Config> Pallet<T> {
                 .iter()
                 .any(|&c| c != I32F32::saturating_from_num(0))
         {
-            // Liquid Alpha is enabled, compute the liquid alphas matrix.
-            let alphas: Vec<Vec<I32F32>> =
-                Self::compute_liquid_alpha_values(netuid, weights, bonds, consensus);
+            // Liquid Alpha is enabled, compute the appropriate consensus for liquid alpha based on mode
+            let consensus_for_liquid_alpha =
+                Self::compute_consensus_for_liquid_alpha(netuid, consensus);
+            log::trace!(
+                "consensus_for_liquid_alpha: {:?}",
+                &consensus_for_liquid_alpha
+            );
+
+            // Compute the liquid alphas matrix.
+            let alphas: Vec<Vec<I32F32>> = Self::compute_liquid_alpha_values(
+                netuid,
+                weights,
+                bonds,
+                &consensus_for_liquid_alpha,
+            );
             log::trace!("alphas: {:?}", &alphas);
 
             // Compute the Exponential Moving Average (EMA) of bonds using the provided clamped alpha values.
@@ -1328,9 +1340,21 @@ impl<T: Config> Pallet<T> {
                 .iter()
                 .any(|&c| c != I32F32::saturating_from_num(0))
         {
-            // Liquid Alpha is enabled, compute the liquid alphas matrix.
-            let alphas: Vec<Vec<I32F32>> =
-                Self::compute_liquid_alpha_values_sparse(netuid, weights, bonds, consensus);
+            // Liquid Alpha is enabled, compute the appropriate consensus for liquid alpha based on mode
+            let consensus_for_liquid_alpha =
+                Self::compute_consensus_for_liquid_alpha(netuid, consensus);
+            log::trace!(
+                "consensus_for_liquid_alpha: {:?}",
+                &consensus_for_liquid_alpha
+            );
+
+            // Compute the liquid alphas matrix.
+            let alphas: Vec<Vec<I32F32>> = Self::compute_liquid_alpha_values_sparse(
+                netuid,
+                weights,
+                bonds,
+                &consensus_for_liquid_alpha,
+            );
             log::trace!("alphas: {:?}", &alphas);
 
             // Compute the Exponential Moving Average (EMA) of bonds using the provided clamped alpha values.
@@ -1344,6 +1368,55 @@ impl<T: Config> Pallet<T> {
         }
     }
 
+    /// Compute the consensus to use for liquid alpha calculation based on the configured mode
+    ///
+    /// # Args:
+    /// * `netuid` - The network ID.
+    /// * `current_consensus` - The current in-memory consensus values.
+    ///
+    /// # Returns:
+    /// A vector of consensus values to use for liquid alpha calculation
+    pub fn compute_consensus_for_liquid_alpha(
+        netuid: NetUid,
+        current_consensus: &[I32F32],
+    ) -> Vec<I32F32> {
+        let mode = Self::get_liquid_alpha_consensus_mode(netuid);
+
+        match mode {
+            ConsensusMode::Current => {
+                // Use the in-memory consensus (current behavior)
+                current_consensus.to_vec()
+            }
+            ConsensusMode::Previous => {
+                // Use consensus from storage
+                let previous_consensus_u16 = Consensus::<T>::get(netuid);
+                previous_consensus_u16
+                    .iter()
+                    .map(|&c| {
+                        I32F32::saturating_from_num(c)
+                            .safe_div(I32F32::saturating_from_num(u16::MAX))
+                    })
+                    .collect()
+            }
+            ConsensusMode::Auto => {
+                // Auto mode: Previous if bond_penalty == 1, otherwise Current
+                let bonds_penalty = Self::get_float_bonds_penalty(netuid);
+                if bonds_penalty == I32F32::from_num(1) {
+                    let previous_consensus_u16 = Consensus::<T>::get(netuid);
+                    previous_consensus_u16
+                        .iter()
+                        .map(|&c| {
+                            I32F32::saturating_from_num(c)
+                                .safe_div(I32F32::saturating_from_num(u16::MAX))
+                        })
+                        .collect()
+                } else {
+                    current_consensus.to_vec()
+                }
+            }
+        }
+    }
+
     /// Compute liquid alphas matrix
     /// There is a separate alpha param for each validator-miner binding
     ///
@@ -1551,6 +1624,19 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
+    pub fn do_set_liquid_alpha_consensus_mode(
+        origin: OriginFor<T>,
+        netuid: NetUid,
+        mode: ConsensusMode,
+    ) -> Result<(), DispatchError> {
+        Self::ensure_subnet_owner_or_root(origin, netuid)?;
+
+        Self::set_liquid_alpha_consensus_mode(netuid, mode.clone());
+
+        log::debug!("LiquidAlphaConsensusModeSet( netuid: {netuid:?}, mode: {mode:?} )",);
+        Ok(())
+    }
+
     pub fn do_reset_bonds(
         netuid_index: NetUidStorageIndex,
         account_id: &T::AccountId,

pallets/subtensor/src/lib.rs

@@ -348,6 +348,18 @@ pub mod pallet {
         },
     }
 
+    /// Enum for consensus mode used in liquid alpha calculation
+    #[derive(Encode, Decode, Default, TypeInfo, Clone, PartialEq, Eq, Debug)]
+    pub enum ConsensusMode {
+        /// Use current in-memory consensus (current behavior)
+        Current,
+        /// Use previous consensus from storage
+        Previous,
+        /// Auto mode: Previous if bond_penalty == 1, otherwise Current
+        #[default]
+        Auto,
+    }
+
     /// The Max Burn HalfLife Settable
     #[pallet::type_value]
     pub fn MaxBurnHalfLife<T: Config>() -> u16 {
@@ -975,6 +987,12 @@ pub mod pallet {
         (45875, 58982)
     }
 
+    /// Default consensus mode for liquid alpha calculation
+    #[pallet::type_value]
+    pub fn DefaultConsensusMode<T: Config>() -> ConsensusMode {
+        ConsensusMode::default()
+    }
+
     /// Default value for coldkey swap announcement delay.
     #[pallet::type_value]
     pub fn DefaultColdkeySwapAnnouncementDelay<T: Config>() -> BlockNumberFor<T> {
@@ -1942,6 +1960,11 @@ pub mod pallet {
     pub type AlphaValues<T> =
         StorageMap<_, Identity, NetUid, (u16, u16), ValueQuery, DefaultAlphaValues<T>>;
 
+    /// MAP ( netuid ) --> consensus mode for liquid alpha calculation
+    #[pallet::storage]
+    pub type LiquidAlphaConsensusMode<T> =
+        StorageMap<_, Identity, NetUid, ConsensusMode, ValueQuery, DefaultConsensusMode<T>>;
+
     /// --- MAP ( netuid ) --> If subtoken trading enabled
     #[pallet::storage]
     pub type SubtokenEnabled<T> =