Merge pull request #1984 from opentensor/feat/subsubnets

Subsubnets

Author: sam0x17

common/src/lib.rs

@@ -224,6 +224,162 @@ pub mod time {
     pub const DAYS: BlockNumber = HOURS * 24;
 }
 
+#[freeze_struct("8e576b32bb1bb664")]
+#[repr(transparent)]
+#[derive(
+    Deserialize,
+    Serialize,
+    Clone,
+    Copy,
+    Decode,
+    DecodeWithMemTracking,
+    Default,
+    Encode,
+    Eq,
+    Hash,
+    MaxEncodedLen,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    RuntimeDebug,
+)]
+#[serde(transparent)]
+pub struct SubId(u8);
+
+impl SubId {
+    pub const MAIN: SubId = Self(0);
+}
+
+impl From<u8> for SubId {
+    fn from(value: u8) -> Self {
+        Self(value)
+    }
+}
+
+impl From<SubId> for u16 {
+    fn from(val: SubId) -> Self {
+        u16::from(val.0)
+    }
+}
+
+impl From<SubId> for u64 {
+    fn from(val: SubId) -> Self {
+        u64::from(val.0)
+    }
+}
+
+impl From<SubId> for u8 {
+    fn from(val: SubId) -> Self {
+        u8::from(val.0)
+    }
+}
+
+impl Display for SubId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl CompactAs for SubId {
+    type As = u8;
+
+    fn encode_as(&self) -> &Self::As {
+        &self.0
+    }
+
+    fn decode_from(v: Self::As) -> Result<Self, CodecError> {
+        Ok(Self(v))
+    }
+}
+
+impl From<Compact<SubId>> for SubId {
+    fn from(c: Compact<SubId>) -> Self {
+        c.0
+    }
+}
+
+impl TypeInfo for SubId {
+    type Identity = <u8 as TypeInfo>::Identity;
+    fn type_info() -> scale_info::Type {
+        <u8 as TypeInfo>::type_info()
+    }
+}
+
+#[freeze_struct("2d995c5478e16d4d")]
+#[repr(transparent)]
+#[derive(
+    Deserialize,
+    Serialize,
+    Clone,
+    Copy,
+    Decode,
+    DecodeWithMemTracking,
+    Default,
+    Encode,
+    Eq,
+    Hash,
+    MaxEncodedLen,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    RuntimeDebug,
+)]
+#[serde(transparent)]
+pub struct NetUidStorageIndex(u16);
+
+impl NetUidStorageIndex {
+    pub const ROOT: NetUidStorageIndex = Self(0);
+}
+
+impl Display for NetUidStorageIndex {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl CompactAs for NetUidStorageIndex {
+    type As = u16;
+
+    fn encode_as(&self) -> &Self::As {
+        &self.0
+    }
+
+    fn decode_from(v: Self::As) -> Result<Self, CodecError> {
+        Ok(Self(v))
+    }
+}
+
+impl From<Compact<NetUidStorageIndex>> for NetUidStorageIndex {
+    fn from(c: Compact<NetUidStorageIndex>) -> Self {
+        c.0
+    }
+}
+
+impl From<NetUid> for NetUidStorageIndex {
+    fn from(val: NetUid) -> Self {
+        val.0.into()
+    }
+}
+
+impl From<NetUidStorageIndex> for u16 {
+    fn from(val: NetUidStorageIndex) -> Self {
+        val.0
+    }
+}
+
+impl From<u16> for NetUidStorageIndex {
+    fn from(value: u16) -> Self {
+        Self(value)
+    }
+}
+
+impl TypeInfo for NetUidStorageIndex {
+    type Identity = <u16 as TypeInfo>::Identity;
+    fn type_info() -> scale_info::Type {
+        <u16 as TypeInfo>::type_info()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

pallets/admin-utils/src/lib.rs

@@ -9,7 +9,7 @@ pub use pallet::*;
 // - we could use a type parameter for `AuthorityId`, but there is
 //   no sense for this as GRANDPA's `AuthorityId` is not a parameter -- it's always the same
 use sp_consensus_grandpa::AuthorityList;
-use sp_runtime::{DispatchResult, RuntimeAppPublic, traits::Member};
+use sp_runtime::{DispatchResult, RuntimeAppPublic, Vec, traits::Member};
 
 mod benchmarking;
 
@@ -28,7 +28,7 @@ pub mod pallet {
     use pallet_subtensor::utils::rate_limiting::TransactionType;
     use sp_runtime::BoundedVec;
     use substrate_fixed::types::I96F32;
-    use subtensor_runtime_common::{NetUid, TaoCurrency};
+    use subtensor_runtime_common::{NetUid, SubId, TaoCurrency};
 
     /// The main data structure of the module.
     #[pallet::pallet]
@@ -1846,6 +1846,58 @@ pub mod pallet {
             log::debug!("OwnerHyperparamRateLimitSet( limit: {limit:?} ) ");
             Ok(())
         }
+
+        /// Sets the desired number of subsubnets in a subnet
+        #[pallet::call_index(76)]
+        #[pallet::weight(Weight::from_parts(15_000_000, 0)
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
+        pub fn sudo_set_subsubnet_count(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            subsub_count: SubId,
+        ) -> DispatchResult {
+            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
+                origin,
+                netuid,
+                &[TransactionType::SubsubnetParameterUpdate],
+            )?;
+
+            pallet_subtensor::Pallet::<T>::do_set_subsubnet_count(netuid, subsub_count)?;
+
+            pallet_subtensor::Pallet::<T>::record_owner_rl(
+                maybe_owner,
+                netuid,
+                &[TransactionType::SubsubnetParameterUpdate],
+            );
+            Ok(())
+        }
+
+        /// Sets the emission split between subsubnets in a subnet
+        #[pallet::call_index(77)]
+        #[pallet::weight(Weight::from_parts(15_000_000, 0)
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
+        pub fn sudo_set_subsubnet_emission_split(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            maybe_split: Option<Vec<u16>>,
+        ) -> DispatchResult {
+            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
+                origin,
+                netuid,
+                &[TransactionType::SubsubnetParameterUpdate],
+            )?;
+
+            pallet_subtensor::Pallet::<T>::do_set_emission_split(netuid, maybe_split)?;
+
+            pallet_subtensor::Pallet::<T>::record_owner_rl(
+                maybe_owner,
+                netuid,
+                &[TransactionType::SubsubnetParameterUpdate],
+            );
+            Ok(())
+        }
     }
 }
 

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

@@ -11,7 +11,7 @@ use pallet_subtensor::Event;
 use sp_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_core::{Get, Pair, U256, ed25519};
 use substrate_fixed::types::I96F32;
-use subtensor_runtime_common::{Currency, NetUid, TaoCurrency};
+use subtensor_runtime_common::{Currency, NetUid, SubId, TaoCurrency};
 
 use crate::Error;
 use crate::pallet::PrecompileEnable;
@@ -827,7 +827,7 @@ fn test_sudo_set_bonds_moving_average() {
         let netuid = NetUid::from(1);
         let to_be_set: u64 = 10;
         add_network(netuid, 10);
-        let init_value: u64 = SubtensorModule::get_bonds_moving_average(netuid);
+        let init_value: u64 = SubtensorModule::get_bonds_moving_average(netuid.into());
         assert_eq!(
             AdminUtils::sudo_set_bonds_moving_average(
                 <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
@@ -845,15 +845,18 @@ fn test_sudo_set_bonds_moving_average() {
             Err(Error::<Test>::SubnetDoesNotExist.into())
         );
         assert_eq!(
-            SubtensorModule::get_bonds_moving_average(netuid),
+            SubtensorModule::get_bonds_moving_average(netuid.into()),
             init_value
         );
         assert_ok!(AdminUtils::sudo_set_bonds_moving_average(
             <<Test as Config>::RuntimeOrigin>::root(),
             netuid,
             to_be_set
         ));
-        assert_eq!(SubtensorModule::get_bonds_moving_average(netuid), to_be_set);
+        assert_eq!(
+            SubtensorModule::get_bonds_moving_average(netuid.into()),
+            to_be_set
+        );
     });
 }
 
@@ -2227,3 +2230,42 @@ fn test_sudo_set_max_burn() {
         );
     });
 }
+
+#[test]
+fn test_sudo_set_subsubnet_count() {
+    new_test_ext().execute_with(|| {
+        let netuid = NetUid::from(1);
+        let ss_count_ok = SubId::from(8);
+        let ss_count_bad = SubId::from(9);
+
+        let sn_owner = U256::from(1324);
+        add_network(netuid, 10);
+        // Set the Subnet Owner
+        SubnetOwner::<Test>::insert(netuid, sn_owner);
+
+        assert_eq!(
+            AdminUtils::sudo_set_subsubnet_count(
+                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
+                netuid,
+                ss_count_ok
+            ),
+            Err(DispatchError::BadOrigin)
+        );
+        assert_noop!(
+            AdminUtils::sudo_set_subsubnet_count(RuntimeOrigin::root(), netuid, ss_count_bad),
+            pallet_subtensor::Error::<Test>::InvalidValue
+        );
+
+        assert_ok!(AdminUtils::sudo_set_subsubnet_count(
+            <<Test as Config>::RuntimeOrigin>::root(),
+            netuid,
+            ss_count_ok
+        ));
+
+        assert_ok!(AdminUtils::sudo_set_subsubnet_count(
+            <<Test as Config>::RuntimeOrigin>::signed(sn_owner),
+            netuid,
+            ss_count_ok
+        ));
+    });
+}