Merge branch 'devnet-ready' into feat/recycle-from-burn-uid

Author: camfairchild

Cargo.lock

@@ -113,6 +113,7 @@ expander = "2"
 ahash = { version = "0.8", default-features = false }
 regex = { version = "1.11.1", default-features = false }
 
+frame = { package = "polkadot-sdk-frame", git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2503-6", default-features = false }
 frame-benchmarking = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2503-6", default-features = false }
 frame-benchmarking-cli = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2503-6", default-features = false }
 frame-executive = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2503-6", default-features = false }

Cargo.toml

@@ -1,26 +1,40 @@
 import * as assert from "assert";
-import { getAliceSigner, getDevnetApi } from "../src/substrate"
+import { getAliceSigner, getDevnetApi, getRandomSubstrateKeypair } from "../src/substrate"
 import { generateRandomEthersWallet, getPublicClient } from "../src/utils";
 import { IDISPATCH_ADDRESS, ISTORAGE_QUERY_ADDRESS, ETH_LOCAL_URL } from "../src/config";
 import { devnet, MultiAddress } from "@polkadot-api/descriptors"
-import { hexToNumber, PublicClient } from "viem";
-import { PolkadotSigner, TypedApi } from "polkadot-api";
+import { PublicClient } from "viem";
+import { PolkadotSigner, TypedApi, getTypedCodecs } from "polkadot-api";
 import { convertPublicKeyToSs58 } from "../src/address-utils"
-import { forceSetBalanceToEthAddress, setMaxChildkeyTake } from "../src/subtensor";
-import { xxhashAsU8a } from '@polkadot/util-crypto';
-import { u8aToHex } from '@polkadot/util';
+import { forceSetBalanceToEthAddress, setMaxChildkeyTake, burnedRegister, forceSetBalanceToSs58Address, addStake, setTxRateLimit, addNewSubnetwork, startCall, setTempo } from "../src/subtensor";
 
 describe("Test the dispatch precompile", () => {
     let publicClient: PublicClient;
     const wallet1 = generateRandomEthersWallet();
     let api: TypedApi<typeof devnet>
     let alice: PolkadotSigner;
+    const hotkey = getRandomSubstrateKeypair();
+    const coldkey = getRandomSubstrateKeypair();
+    let netuid: number;
 
     before(async () => {
         publicClient = await getPublicClient(ETH_LOCAL_URL)
         api = await getDevnetApi()
         alice = await getAliceSigner()
         await forceSetBalanceToEthAddress(api, wallet1.address)
+
+        await forceSetBalanceToSs58Address(api, convertPublicKeyToSs58(hotkey.publicKey))
+        await forceSetBalanceToSs58Address(api, convertPublicKeyToSs58(coldkey.publicKey))
+
+
+        netuid = await addNewSubnetwork(api, hotkey, coldkey)
+        // set tempo big enough to avoid stake value updated with fast block feature
+        await setTempo(api, netuid, 10000)
+        await startCall(api, netuid, coldkey)
+        await setTxRateLimit(api, BigInt(0))
+
+        await burnedRegister(api, netuid, convertPublicKeyToSs58(hotkey.publicKey), coldkey)
+        await addStake(api, netuid, convertPublicKeyToSs58(hotkey.publicKey), BigInt(1_000_000_000), coldkey)
     })
 
     it("Dispatch transfer call via precompile contract works correctly", async () => {
@@ -49,27 +63,73 @@ describe("Test the dispatch precompile", () => {
     })
 
 
-    it("Storage query call via precompile contract works correctly", async () => {
-        const palletPrefixBytes = xxhashAsU8a("SubtensorModule", 128);
-        const storageItemPrefixBytes = xxhashAsU8a("MaxChildkeyTake", 128);
-        const fullStorageKeyBytes = new Uint8Array([...palletPrefixBytes, ...storageItemPrefixBytes]);
-        // 0x658faa385070e074c85bf6b568cf0555dba018859cab7e989f77669457b394be
-        // key for max child key take
-        const fullStorageKeyHex = u8aToHex(fullStorageKeyBytes);
+    it("Value type storage query call via precompile contract works correctly", async () => {
+        const key = await api.query.SubtensorModule.MaxChildkeyTake.getKey();
 
         let maxChildkeyTake = 257;
         await setMaxChildkeyTake(api, maxChildkeyTake)
 
         api.query.SubtensorModule.MaxChildkeyTake.getValue();
         const rawCallResponse = await publicClient.call({
             to: ISTORAGE_QUERY_ADDRESS,
-            data: fullStorageKeyHex,
+            data: key.toString() as `0x${string}`,
+        })
+        const rawResultData = rawCallResponse.data ?? "";
+
+        const codec = await getTypedCodecs(devnet);
+        const maxChildkeyTakeCodec = codec.query.SubtensorModule.MaxChildkeyTake.value;
+        const maxChildkeyTakeFromContract = maxChildkeyTakeCodec.dec(rawResultData);
+        assert.equal(maxChildkeyTakeFromContract, maxChildkeyTake, "value should be 257")
+    })
+
+    it("Map type storage query call via precompile contract works correctly", async () => {
+
+        const key = await api.query.SubtensorModule.Tempo.getKey(netuid);
+
+        const tempoOnChain = await api.query.SubtensorModule.Tempo.getValue(netuid);
+        const rawCallResponse = await publicClient.call({
+            to: ISTORAGE_QUERY_ADDRESS,
+            data: key.toString() as `0x${string}`,
         })
-        const rawResultData = rawCallResponse.data;
-        if (rawResultData === undefined) {
-            throw new Error("rawResultData is undefined");
-        }
-        let value = hexToNumber(rawResultData);
-        assert.equal(value, maxChildkeyTake, "value should be 257")
+        const rawResultData = rawCallResponse.data ?? "";
+
+        const codec = await getTypedCodecs(devnet);
+        const maxChildkeyTakeValueCodec = codec.query.SubtensorModule.Tempo.value;
+        const decodedValue = maxChildkeyTakeValueCodec.dec(rawResultData);
+        assert.equal(tempoOnChain, decodedValue, "value should be the same as on chain")
+    })
+
+    it("Double map type storage query call via precompile contract works correctly", async () => {
+        const key = await api.query.SubtensorModule.TotalHotkeyAlpha.getKey(convertPublicKeyToSs58(hotkey.publicKey), netuid);
+        const totalHotkeyAlphaOnChain = await api.query.SubtensorModule.TotalHotkeyAlpha.getValue(convertPublicKeyToSs58(hotkey.publicKey), netuid);
+
+        const rawCallResponse = await publicClient.call({
+            to: ISTORAGE_QUERY_ADDRESS,
+            data: key.toString() as `0x${string}`,
+        })
+        const rawResultData = rawCallResponse.data ?? "";
+        const codec = await getTypedCodecs(devnet);
+        const totalHotkeyAlphaValueCodec = codec.query.SubtensorModule.TotalHotkeyAlpha.value;
+        const decodedValue = totalHotkeyAlphaValueCodec.dec(rawResultData);
+        assert.equal(totalHotkeyAlphaOnChain, decodedValue, "value should be the same as on chain")
+
     })
+
+    // Polkadot api can't decode the boolean type for now.
+    // it("Double map type storage query call via precompile contract works correctly", async () => {
+    //     const key = await api.query.SubtensorModule.IsNetworkMember.getKey(convertPublicKeyToSs58(alice.publicKey), netuid);
+
+    //     const isNetworkMemberOnChain = await api.query.SubtensorModule.IsNetworkMember.getValue(convertPublicKeyToSs58(alice.publicKey), netuid);
+    //     const rawCallResponse = await publicClient.call({
+    //         to: ISTORAGE_QUERY_ADDRESS,
+    //         data: key.toString() as `0x${string}`,
+    //     })
+
+    //     const rawResultData = rawCallResponse.data ?? "";
+    //     const codec = await getTypedCodecs(devnet);
+    //     const isNetworkMemberValueCodec = codec.query.SubtensorModule.IsNetworkMember.value;
+    //     const decodedValue = isNetworkMemberValueCodec.dec(rawResultData);
+    //     assert.equal(isNetworkMemberOnChain, decodedValue, "value should be the same as on chain")
+    // })
+
 });

evm-tests/test/runtime.call.precompile.test.ts

@@ -11,6 +11,8 @@ use frame_benchmarking::v1::account;
 use frame_benchmarking::v2::*;
 use frame_support::BoundedVec;
 use frame_system::RawOrigin;
+use pallet_subtensor::SubnetworkN;
+use subtensor_runtime_common::NetUid;
 
 use super::*;
 
@@ -238,6 +240,19 @@ mod benchmarks {
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 3u16/*kappa*/)/*set_kappa*/;
     }
 
+    #[benchmark]
+    fn sudo_set_min_allowed_uids() {
+        let netuid = NetUid::from(1);
+        pallet_subtensor::Pallet::<T>::set_admin_freeze_window(0);
+        pallet_subtensor::Pallet::<T>::init_new_network(netuid, 1u16 /*tempo*/);
+
+        // Artificially set that some neurons are already registered
+        SubnetworkN::<T>::set(netuid, 32);
+
+        #[extrinsic_call]
+		_(RawOrigin::Root, netuid, 16u16/*min_allowed_uids*/)/*sudo_set_min_allowed_uids*/;
+    }
+
     #[benchmark]
     fn sudo_set_max_allowed_uids() {
         // disable admin freeze window
@@ -432,5 +447,17 @@ mod benchmarks {
         _(RawOrigin::Root, 1u16.into()/*netuid*/, 5u16/*immune_neurons*/)/*sudo_set_owner_immune_neuron_limit()*/;
     }
 
+    #[benchmark]
+    fn sudo_trim_to_max_allowed_uids() {
+        pallet_subtensor::Pallet::<T>::set_admin_freeze_window(0);
+        pallet_subtensor::Pallet::<T>::init_new_network(
+            1u16.into(), /*netuid*/
+            1u16,        /*sudo_tempo*/
+        );
+
+        #[extrinsic_call]
+		_(RawOrigin::Root, 1u16.into()/*netuid*/, 256u16/*max_n*/)/*sudo_trim_to_max_allowed_uids()*/;
+    }
+
     //impl_benchmark_test_suite!(AdminUtils, crate::mock::new_test_ext(), crate::mock::Test);
 }

pallets/admin-utils/src/benchmarking.rs

@@ -106,6 +106,10 @@ pub mod pallet {
         NegativeSigmoidSteepness,
         /// Value not in allowed bounds.
         ValueNotInBounds,
+        /// The minimum allowed UIDs must be less than the current number of UIDs in the subnet.
+        MinAllowedUidsGreaterThanCurrentUids,
+        /// The minimum allowed UIDs must be less than the maximum allowed UIDs.
+        MinAllowedUidsGreaterThanMaxAllowedUids,
     }
     /// Enum for specifying the type of precompile operation.
     #[derive(
@@ -1080,6 +1084,23 @@ pub mod pallet {
             Ok(())
         }
 
+        /// The extrinsic sets the subnet limit for the network.
+        /// It is only callable by the root account.
+        /// The extrinsic will call the Subtensor pallet to set the subnet limit.
+        #[pallet::call_index(37)]
+        #[pallet::weight((
+			Weight::from_parts(14_000_000, 0)
+				.saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1)),
+			DispatchClass::Operational,
+			Pays::No
+		))]
+        pub fn sudo_set_subnet_limit(origin: OriginFor<T>, max_subnets: u16) -> DispatchResult {
+            ensure_root(origin)?;
+            pallet_subtensor::Pallet::<T>::set_max_subnets(max_subnets);
+            log::debug!("MaxSubnets ( max_subnets: {max_subnets:?} ) ");
+            Ok(())
+        }
+
         /// The extrinsic sets the lock reduction interval for the network.
         /// It is only callable by the root account.
         /// The extrinsic will call the Subtensor pallet to set the lock reduction interval.
@@ -1902,6 +1923,70 @@ pub mod pallet {
             );
             Ok(())
         }
+
+        /// Trims the maximum number of UIDs for a subnet.
+        ///
+        /// The trimming is done by sorting the UIDs by emission descending and then trimming
+        /// the lowest emitters while preserving temporally and owner immune UIDs. The UIDs are
+        /// then compressed to the left and storage is migrated to the new compressed UIDs.
+        #[pallet::call_index(78)]
+        #[pallet::weight(Weight::from_parts(32_880_000, 0)
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(6_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
+        pub fn sudo_trim_to_max_allowed_uids(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            max_n: u16,
+        ) -> DispatchResult {
+            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
+                origin.clone(),
+                netuid,
+                &[TransactionType::MaxUidsTrimming],
+            )?;
+
+            pallet_subtensor::Pallet::<T>::trim_to_max_allowed_uids(netuid, max_n)?;
+
+            pallet_subtensor::Pallet::<T>::record_owner_rl(
+                maybe_owner,
+                netuid,
+                &[TransactionType::MaxUidsTrimming],
+            );
+            Ok(())
+        }
+
+        /// The extrinsic sets the minimum allowed UIDs for a subnet.
+        /// It is only callable by the root account.
+        #[pallet::call_index(79)]
+        #[pallet::weight(Weight::from_parts(31_550_000, 0)
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(5_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
+        pub fn sudo_set_min_allowed_uids(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            min_allowed_uids: u16,
+        ) -> DispatchResult {
+            pallet_subtensor::Pallet::<T>::ensure_root_with_rate_limit(origin, netuid)?;
+
+            ensure!(
+                pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
+                Error::<T>::SubnetDoesNotExist
+            );
+            ensure!(
+                min_allowed_uids < pallet_subtensor::Pallet::<T>::get_max_allowed_uids(netuid),
+                Error::<T>::MinAllowedUidsGreaterThanMaxAllowedUids
+            );
+            ensure!(
+                min_allowed_uids < pallet_subtensor::Pallet::<T>::get_subnetwork_n(netuid),
+                Error::<T>::MinAllowedUidsGreaterThanCurrentUids
+            );
+
+            pallet_subtensor::Pallet::<T>::set_min_allowed_uids(netuid, min_allowed_uids);
+
+            log::debug!(
+                "MinAllowedUidsSet( netuid: {netuid:?} min_allowed_uids: {min_allowed_uids:?} ) "
+            );
+            Ok(())
+        }
     }
 }