Subnet sale offer

pallets/subtensor/src/benchmarks.rs

@@ -175,6 +175,24 @@ mod pallet_benchmarks {
         ecdsa::Signature::from_raw(signature)
     }
 
+    fn setup_subnet_sale_offer<T: Config>()
+    -> (NetUid, T::AccountId, T::AccountId, T::AccountId, TaoBalance) {
+        let netuid = NetUid::from(1);
+        let seller: T::AccountId = whitelisted_caller();
+        let owner_hotkey: T::AccountId = account("owner_hotkey", 0, 0);
+        let authorized_buyer: T::AccountId = account("authorized_buyer", 0, 0);
+        let price = TaoBalance::from(1_000_000_000_u64);
+
+        Subtensor::<T>::init_new_network(netuid, 1);
+        SubnetOwner::<T>::insert(netuid, seller.clone());
+        assert_ok!(Subtensor::<T>::set_subnet_owner_hotkey(
+            netuid,
+            &owner_hotkey
+        ));
+
+        (netuid, seller, owner_hotkey, authorized_buyer, price)
+    }
+
     #[benchmark]
     fn register() {
         let netuid = NetUid::from(1);
@@ -1851,6 +1869,49 @@ mod pallet_benchmarks {
         assert!(!AccumulatedLeaseDividends::<T>::contains_key(lease_id));
     }
 
+    #[benchmark]
+    fn create_sale_offer() {
+        let (netuid, seller, owner_hotkey, authorized_buyer, price) =
+            setup_subnet_sale_offer::<T>();
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::Signed(seller.clone()),
+            netuid,
+            price,
+            Some(authorized_buyer.clone()),
+        );
+
+        let offer = SubnetSaleOffers::<T>::get(netuid).unwrap();
+        assert_eq!(offer.netuid, netuid);
+        assert_eq!(offer.seller, seller);
+        assert_eq!(offer.authorized_buyer, Some(authorized_buyer));
+        assert_eq!(offer.price, price.into());
+        assert_eq!(offer.created_at, frame_system::Pallet::<T>::block_number());
+        assert!(SubnetSaleFrozenColdkeys::<T>::contains_key(&offer.seller));
+        assert!(SubnetSaleFrozenHotkeys::<T>::contains_key(&owner_hotkey));
+    }
+
+    #[benchmark]
+    fn cancel_sale_offer() {
+        let (netuid, seller, owner_hotkey, authorized_buyer, price) =
+            setup_subnet_sale_offer::<T>();
+
+        assert_ok!(Subtensor::<T>::create_sale_offer(
+            RawOrigin::Signed(seller.clone()).into(),
+            netuid,
+            price,
+            Some(authorized_buyer),
+        ));
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(seller.clone()), netuid);
+
+        assert!(!SubnetSaleOffers::<T>::contains_key(netuid));
+        assert!(!SubnetSaleFrozenColdkeys::<T>::contains_key(seller));
+        assert!(!SubnetSaleFrozenHotkeys::<T>::contains_key(owner_hotkey));
+    }
+
     #[benchmark]
     fn update_symbol() {
         let coldkey: T::AccountId = whitelisted_caller();

pallets/subtensor/src/coinbase/root.rs

@@ -308,7 +308,7 @@ impl<T: Config> Pallet<T> {
         // --- 13. Token / mechanism / registration toggles.
         TokenSymbol::<T>::remove(netuid);
         SubnetMechanism::<T>::remove(netuid);
-        SubnetOwnerHotkey::<T>::remove(netuid);
+        let owner_hotkey = SubnetOwnerHotkey::<T>::take(netuid);
         NetworkRegistrationAllowed::<T>::remove(netuid);
         NetworkPowRegistrationAllowed::<T>::remove(netuid);
 
@@ -471,6 +471,12 @@ impl<T: Config> Pallet<T> {
             AccumulatedLeaseDividends::<T>::remove(lease_id);
         }
 
+        // --- 23. Subnet sale offers: release sale locks.
+        if let Some(offer) = SubnetSaleOffers::<T>::take(netuid) {
+            SubnetSaleFrozenColdkeys::<T>::remove(&offer.seller);
+            SubnetSaleFrozenHotkeys::<T>::remove(&owner_hotkey);
+        }
+
         // --- 23: Locks cleanup
         Self::destroy_lock_maps(netuid);
 

pallets/subtensor/src/guards/check_coldkey_swap.rs

@@ -99,7 +99,7 @@ mod tests {
         weights::WeightInfo as _,
     };
     use frame_support::{
-        BoundedVec, assert_ok,
+        BoundedVec, assert_noop, assert_ok,
         dispatch::{DispatchExtension, DispatchResultWithPostInfo},
         traits::ExtendedDispatchable,
     };
@@ -134,6 +134,11 @@ mod tests {
             RuntimeCall::SubtensorModule(crate::Call::register_network {
                 hotkey: U256::from(1),
             }),
+            RuntimeCall::SubtensorModule(crate::Call::create_sale_offer {
+                netuid: 1u16.into(),
+                price: TaoBalance::from(1_000_u64),
+                authorized_buyer: None,
+            }),
         ]
     }