Liquid Alpha 2.1 Consensus Modes

.github/workflows/check-bittensor-e2e-tests.yml

@@ -448,11 +448,19 @@ jobs:
           path: rust-e2e
 
       - name: Login to GHCR
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
+        env:
+          GHCR_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          for i in 1 2 3; do
+            if printf '%s' "$GHCR_TOKEN" \
+              | docker login ghcr.io --username "$GITHUB_ACTOR" --password-stdin; then
+              exit 0
+            fi
+            echo "GHCR login failed (attempt $i), retrying in $((i * 15))s..."
+            sleep $((i * 15))
+          done
+          printf '%s' "$GHCR_TOKEN" \
+            | docker login ghcr.io --username "$GITHUB_ACTOR" --password-stdin
 
       - name: Pull Docker Image
         # GHCR intermittently returns permission_denied/timeouts under the

pallets/admin-utils/src/benchmarking.rs

@@ -516,6 +516,20 @@ mod benchmarks {
         _(RawOrigin::Root, netuid, 2000u16, 3000u16);
     }
 
+    #[benchmark]
+    fn sudo_set_liquid_alpha_consensus_mode() {
+        let netuid = NetUid::from(1);
+        pallet_subtensor::Pallet::<T>::set_admin_freeze_window(0);
+        pallet_subtensor::Pallet::<T>::init_new_network(netuid, 1u16);
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::Root,
+            netuid,
+            pallet_subtensor::ConsensusMode::Previous,
+        );
+    }
+
     #[benchmark]
     fn sudo_set_coldkey_swap_announcement_delay() {
         #[extrinsic_call]

pallets/admin-utils/src/lib.rs

@@ -30,7 +30,7 @@ pub mod pallet {
     use frame_system::pallet_prelude::*;
     use pallet_evm_chain_id::{self, ChainId};
     use pallet_subtensor::{
-        DefaultMaxAllowedUids,
+        ConsensusMode, DefaultMaxAllowedUids, MAX_BONDS_MOVING_AVERAGE,
         utils::rate_limiting::{Hyperparameter, TransactionType},
     };
     use sp_runtime::{BoundedVec, PerU16};
@@ -921,7 +921,7 @@ pub mod pallet {
             pallet_subtensor::Pallet::<T>::ensure_admin_window_open(netuid)?;
             if maybe_owner.is_some() {
                 ensure!(
-                    bonds_moving_average <= 975000,
+                    bonds_moving_average <= MAX_BONDS_MOVING_AVERAGE,
                     Error::<T>::BondsMovingAverageMaxReached
                 )
             }
@@ -1340,6 +1340,29 @@ pub mod pallet {
             res
         }
 
+        /// Sets which consensus values liquid alpha uses for a subnet.
+        #[pallet::call_index(104)]
+        #[pallet::weight(<T as pallet::Config>::WeightInfo::sudo_set_alpha_values())]
+        pub fn sudo_set_liquid_alpha_consensus_mode(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            mode: ConsensusMode,
+        ) -> DispatchResult {
+            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
+                origin,
+                netuid,
+                &[Hyperparameter::LiquidAlphaConsensusMode.into()],
+            )?;
+            pallet_subtensor::Pallet::<T>::ensure_admin_window_open(netuid)?;
+            pallet_subtensor::Pallet::<T>::set_liquid_alpha_consensus_mode(netuid, mode);
+            pallet_subtensor::Pallet::<T>::record_owner_rl(
+                maybe_owner,
+                netuid,
+                &[Hyperparameter::LiquidAlphaConsensusMode.into()],
+            );
+            Ok(())
+        }
+
         /// Sets the duration of the dissolve network schedule.
         ///
         /// This extrinsic allows the root account to set the duration for the dissolve network schedule.

pallets/admin-utils/src/tests/mod.rs

@@ -1,4 +1,5 @@
 use crate::{Error, pallet::PrecompileEnable};
+use codec::Encode;
 use frame_support::{
     assert_err, assert_noop, assert_ok,
     dispatch::{DispatchClass, GetDispatchInfo, Pays},
@@ -1348,6 +1349,77 @@ fn test_sudo_set_liquid_alpha_enabled() {
     });
 }
 
+#[test]
+fn test_sudo_set_liquid_alpha_consensus_mode() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+        NetworksAdded::<Test>::insert(netuid, true);
+        assert_eq!(
+            SubtensorModule::get_liquid_alpha_consensus_mode(netuid),
+            ConsensusMode::Auto
+        );
+
+        assert_err!(
+            AdminUtils::sudo_set_liquid_alpha_consensus_mode(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                netuid,
+                ConsensusMode::Previous,
+            ),
+            DispatchError::BadOrigin
+        );
+
+        for mode in [
+            ConsensusMode::Current,
+            ConsensusMode::Previous,
+            ConsensusMode::Auto,
+        ] {
+            assert_ok!(AdminUtils::sudo_set_liquid_alpha_consensus_mode(
+                <<Test as Config>::RuntimeOrigin>::root(),
+                netuid,
+                mode,
+            ));
+            assert_eq!(
+                SubtensorModule::get_liquid_alpha_consensus_mode(netuid),
+                mode
+            );
+            frame_system::Pallet::<Test>::assert_last_event(RuntimeEvent::SubtensorModule(
+                Event::LiquidAlphaConsensusModeSet(netuid, mode),
+            ));
+        }
+    });
+}
+
+#[test]
+fn test_subnet_owner_can_set_liquid_alpha_consensus_mode() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+        let owner = U256::from(10);
+        add_network(netuid, 10);
+        SubnetOwner::<Test>::insert(netuid, owner);
+        SubtensorModule::set_admin_freeze_window(0);
+
+        assert_ok!(AdminUtils::sudo_set_liquid_alpha_consensus_mode(
+            <<Test as Config>::RuntimeOrigin>::signed(owner),
+            netuid,
+            ConsensusMode::Previous,
+        ));
+        assert_eq!(
+            SubtensorModule::get_liquid_alpha_consensus_mode(netuid),
+            ConsensusMode::Previous
+        );
+    });
+}
+
+#[test]
+fn regression_liquid_alpha_consensus_mode_call_index() {
+    let call = crate::Call::<Test>::sudo_set_liquid_alpha_consensus_mode {
+        netuid: NetUid::from(1),
+        mode: ConsensusMode::Auto,
+    };
+
+    assert_eq!(call.encode().first(), Some(&104));
+}
+
 #[test]
 fn test_sudo_set_alpha_sigmoid_steepness() {
     new_test_ext().execute_with(|| {
@@ -1411,7 +1483,7 @@ fn test_sudo_set_alpha_sigmoid_steepness() {
 fn test_set_alpha_values_dispatch_info_ok() {
     new_test_ext().execute_with(|| {
         let netuid = NetUid::from(1);
-        let alpha_low: u16 = 1638_u16;
+        let alpha_low = MIN_ALPHA_LOW;
         let alpha_high: u16 = u16::MAX - 10;
         let call = RuntimeCall::AdminUtils(crate::Call::sudo_set_alpha_values {
             netuid,
@@ -1430,7 +1502,7 @@ fn test_set_alpha_values_dispatch_info_ok() {
 fn test_sudo_get_set_alpha() {
     new_test_ext().execute_with(|| {
         let netuid = NetUid::from(1);
-        let alpha_low: u16 = 1638_u16;
+        let alpha_low = MIN_ALPHA_LOW;
         let alpha_high: u16 = u16::MAX - 10;
 
         let hotkey: U256 = U256::from(1);
@@ -1509,7 +1581,7 @@ fn test_sudo_get_set_alpha() {
         ));
 
         // 2. Alpha high too low
-        let alpha_high_too_low = (u16::MAX as u32 / 40) as u16 - 1; // One less than the minimum acceptable value
+        let alpha_high_too_low = MIN_ALPHA_LOW - 1;
         assert_err!(
             AdminUtils::sudo_set_alpha_values(
                 signer.clone(),
@@ -1528,7 +1600,7 @@ fn test_sudo_get_set_alpha() {
         ));
 
         // 3. Alpha low too low or too high
-        let alpha_low_too_low = 0_u16;
+        let alpha_low_too_low = MIN_ALPHA_LOW - 1;
         assert_err!(
             AdminUtils::sudo_set_alpha_values(
                 signer.clone(),