Merge branch 'devnet-ready' into fix/clear-small-noms-if-new-min-nom-stake-less

Author: camfairchild

.github/workflows/docker.yml

@@ -9,7 +9,6 @@ on:
         description: "Branch or tag to use for the Docker image tag and ref to checkout (optional)"
         required: false
         default: ""
-
   push:
     branches:
       - devnet-ready
@@ -35,6 +34,13 @@ jobs:
           echo "tag=$branch_or_tag" >> $GITHUB_ENV
           echo "ref=$branch_or_tag" >> $GITHUB_ENV
 
+          # Check if this is a tagged release (not devnet-ready/devnet/testnet)
+          if [[ "${{ github.event_name }}" == "release" && "$branch_or_tag" != "devnet-ready" && "$branch_or_tag" != "devnet" && "$branch_or_tag" != "testnet" ]]; then
+            echo "latest_tag=true" >> $GITHUB_ENV
+          else
+            echo "latest_tag=false" >> $GITHUB_ENV
+          fi
+
       - name: Checkout code
         uses: actions/checkout@v4
         with:
@@ -60,3 +66,4 @@ jobs:
           push: true
           tags: |
             ghcr.io/${{ github.repository }}:${{ env.tag }}
+            ${{ env.latest_tag == 'true' && format('ghcr.io/{0}:latest', github.repository) || '' }}

pallets/admin-utils/src/lib.rs

@@ -1399,6 +1399,36 @@ pub mod pallet {
             log::debug!("SubnetMovingAlphaSet( alpha: {:?} )", alpha);
             Ok(())
         }
+
+        /// Change the SubnetOwnerHotkey for a given subnet.
+        ///
+        /// # Arguments
+        /// * `origin` - The origin of the call, which must be the subnet owner.
+        /// * `netuid` - The unique identifier for the subnet.
+        /// * `hotkey` - The new hotkey for the subnet owner.
+        ///
+        /// # Errors
+        /// * `BadOrigin` - If the caller is not the subnet owner or root account.
+        ///
+        /// # Weight
+        /// Weight is handled by the `#[pallet::weight]` attribute.
+        #[pallet::call_index(64)]
+        #[pallet::weight((0, DispatchClass::Operational, Pays::No))]
+        pub fn sudo_set_subnet_owner_hotkey(
+            origin: OriginFor<T>,
+            netuid: u16,
+            hotkey: T::AccountId,
+        ) -> DispatchResult {
+            pallet_subtensor::Pallet::<T>::ensure_subnet_owner(origin.clone(), netuid)?;
+            pallet_subtensor::Pallet::<T>::set_subnet_owner_hotkey(netuid, &hotkey);
+
+            log::debug!(
+                "SubnetOwnerHotkeySet( netuid: {:?}, hotkey: {:?} )",
+                netuid,
+                hotkey
+            );
+            Ok(())
+        }
     }
 }
 

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

@@ -1549,3 +1549,46 @@ fn test_sets_a_lower_value_clears_small_nominations() {
         );
     });
 }
+
+#[test]
+fn test_sudo_set_subnet_owner_hotkey() {
+    new_test_ext().execute_with(|| {
+        let netuid: u16 = 1;
+
+        let coldkey: U256 = U256::from(1);
+        let hotkey: U256 = U256::from(2);
+        let new_hotkey: U256 = U256::from(3);
+
+        let coldkey_origin = <<Test as Config>::RuntimeOrigin>::signed(coldkey);
+        let root = RuntimeOrigin::root();
+        let random_account = RuntimeOrigin::signed(U256::from(123456));
+
+        pallet_subtensor::SubnetOwner::<Test>::insert(netuid, coldkey);
+        pallet_subtensor::SubnetOwnerHotkey::<Test>::insert(netuid, hotkey);
+        assert_eq!(
+            pallet_subtensor::SubnetOwnerHotkey::<Test>::get(netuid),
+            hotkey
+        );
+
+        assert_ok!(AdminUtils::sudo_set_subnet_owner_hotkey(
+            coldkey_origin,
+            netuid,
+            new_hotkey
+        ));
+
+        assert_eq!(
+            pallet_subtensor::SubnetOwnerHotkey::<Test>::get(netuid),
+            new_hotkey
+        );
+
+        assert_noop!(
+            AdminUtils::sudo_set_subnet_owner_hotkey(random_account, netuid, new_hotkey),
+            DispatchError::BadOrigin
+        );
+
+        assert_noop!(
+            AdminUtils::sudo_set_subnet_owner_hotkey(root, netuid, new_hotkey),
+            DispatchError::BadOrigin
+        );
+    });
+}

pallets/subtensor/src/macros/events.rs

@@ -271,5 +271,11 @@ mod events {
         /// Parameters:
         /// (netuid, bool)
         TransferToggle(u16, bool),
+
+        /// The owner hotkey for a subnet has been set.
+        ///
+        /// Parameters:
+        /// (netuid, new_hotkey)
+        SubnetOwnerHotkeySet(u16, T::AccountId),
     }
 }

pallets/subtensor/src/utils/misc.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::{
     Error,
-    system::{ensure_root, ensure_signed_or_root, pallet_prelude::BlockNumberFor},
+    system::{ensure_root, ensure_signed, ensure_signed_or_root, pallet_prelude::BlockNumberFor},
 };
 use safe_math::*;
 use sp_core::Get;
@@ -23,6 +23,15 @@ impl<T: Config> Pallet<T> {
         }
     }
 
+    pub fn ensure_subnet_owner(o: T::RuntimeOrigin, netuid: u16) -> Result<(), DispatchError> {
+        let coldkey = ensure_signed(o);
+        match coldkey {
+            Ok(who) if SubnetOwner::<T>::get(netuid) == who => Ok(()),
+            Ok(_) => Err(DispatchError::BadOrigin),
+            Err(x) => Err(x.into()),
+        }
+    }
+
     // ========================
     // ==== Global Setters ====
     // ========================
@@ -743,4 +752,20 @@ impl<T: Config> Pallet<T> {
         DissolveNetworkScheduleDuration::<T>::set(duration);
         Self::deposit_event(Event::DissolveNetworkScheduleDurationSet(duration));
     }
+
+    /// Set the owner hotkey for a subnet.
+    ///
+    /// # Arguments
+    ///
+    /// * `netuid` - The unique identifier for the subnet.
+    /// * `hotkey` - The new hotkey for the subnet owner.
+    ///
+    /// # Effects
+    ///
+    /// * Update the SubnetOwnerHotkey storage.
+    /// * Emits a SubnetOwnerHotkeySet event.
+    pub fn set_subnet_owner_hotkey(netuid: u16, hotkey: &T::AccountId) {
+        SubnetOwnerHotkey::<T>::insert(netuid, hotkey.clone());
+        Self::deposit_event(Event::SubnetOwnerHotkeySet(netuid, hotkey.clone()));
+    }
 }

runtime/src/lib.rs

@@ -228,7 +228,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 244,
+    spec_version: 245,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,

runtime/src/precompiles/solidity/staking.abi

@@ -94,5 +94,43 @@
         "outputs": [],
         "stateMutability": "nonpayable",
         "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "coldkey",
+                "type": "bytes32"
+            }
+        ],
+        "name": "getTotalColdkeyStake",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "hotkey",
+                "type": "bytes32"
+            }
+        ],
+        "name": "getTotalHotkeyStake",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
     }
 ]

runtime/src/precompiles/solidity/staking.sol

@@ -46,12 +46,36 @@ interface IStaking {
         uint256 netuid
     ) external;
 
-    /**
-     * @dev Delegates staking to a proxy account.
-     *
-     * @param delegate The public key (32 bytes) of the delegate.
-     */
-    function addProxy(bytes32 delegate) external;
+  /**
+   * @dev Returns the amount of RAO staked by the coldkey.
+   *
+   * This function allows external accounts and contracts to query the amount of RAO staked by the coldkey
+   * which effectively calls `get_total_coldkey_stake` on the subtensor pallet with
+   * specified coldkey as a parameter.
+   *
+   * @param coldkey The coldkey public key (32 bytes).
+   * @return The amount of RAO staked by the coldkey.
+   */
+  function getTotalColdkeyStake(bytes32 coldkey) external view returns (uint256);
+
+  /**
+   * @dev Returns the total amount of stake under a hotkey (delegative or otherwise)
+   * 
+   * This function allows external accounts and contracts to query the total amount of RAO staked under a hotkey
+   * which effectively calls `get_total_hotkey_stake` on the subtensor pallet with
+   * specified hotkey as a parameter.
+   * 
+   * @param hotkey The hotkey public key (32 bytes).
+   * @return The total amount of RAO staked under the hotkey.
+   */
+  function getTotalHotkeyStake(bytes32 hotkey) external view returns (uint256);
+
+  /**
+   * @dev Delegates staking to a proxy account.
+   *
+   * @param delegate The public key (32 bytes) of the delegate.
+   */
+  function addProxy(bytes32 delegate) external;
 
     /**
      * @dev Removes staking proxy account.

runtime/src/precompiles/staking.rs

@@ -90,6 +90,43 @@ impl StakingPrecompile {
         handle.try_dispatch_runtime_call(call, RawOrigin::Signed(account_id))
     }
 
+    #[precompile::public("getTotalColdkeyStake(bytes32)")]
+    fn get_total_coldkey_stake(
+        _handle: &mut impl PrecompileHandle,
+        coldkey_h256: H256,
+    ) -> EvmResult<U256> {
+        let (coldkey, _) = parse_pubkey(coldkey_h256.as_bytes())?;
+
+        // get total stake of coldkey
+        let total_stake =
+            pallet_subtensor::Pallet::<Runtime>::get_total_stake_for_coldkey(&coldkey);
+        // Convert to EVM decimals
+        let stake_u256 = U256::from(total_stake);
+        let stake_eth =
+            <Runtime as pallet_evm::Config>::BalanceConverter::into_evm_balance(stake_u256)
+                .ok_or(ExitError::InvalidRange)?;
+
+        Ok(stake_eth)
+    }
+
+    #[precompile::public("getTotalHotkeyStake(bytes32)")]
+    fn get_total_hotkey_stake(
+        _handle: &mut impl PrecompileHandle,
+        hotkey_h256: H256,
+    ) -> EvmResult<U256> {
+        let (hotkey, _) = parse_pubkey(hotkey_h256.as_bytes())?;
+
+        // get total stake of hotkey
+        let total_stake = pallet_subtensor::Pallet::<Runtime>::get_total_stake_for_hotkey(&hotkey);
+        // Convert to EVM decimals
+        let stake_u256 = U256::from(total_stake);
+        let stake_eth =
+            <Runtime as pallet_evm::Config>::BalanceConverter::into_evm_balance(stake_u256)
+                .ok_or(ExitError::InvalidRange)?;
+
+        Ok(stake_eth)
+    }
+
     #[precompile::public("addProxy(bytes32)")]
     fn add_proxy(handle: &mut impl PrecompileHandle, delegate: H256) -> EvmResult<()> {
         let account_id = handle.caller_account_id();