Subnet sale offer

pallets/subtensor/src/benchmarks.rs

@@ -85,6 +85,24 @@ mod pallet_benchmarks {
         );
     }
 
+    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);
@@ -1769,6 +1787,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

@@ -304,7 +304,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);
 
@@ -466,6 +466,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

@@ -83,7 +83,7 @@ where
 #[allow(clippy::expect_used, clippy::unwrap_used)]
 mod tests {
     use crate::{ColdkeySwapAnnouncements, ColdkeySwapDisputes, Error, tests::mock::*};
-    use frame_support::{BoundedVec, assert_ok};
+    use frame_support::{BoundedVec, assert_noop, assert_ok};
     use frame_system::Call as SystemCall;
     use pallet_subtensor_proxy::Call as ProxyCall;
     use sp_core::U256;
@@ -115,6 +115,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,
+            }),
         ]
     }
 
@@ -189,9 +194,9 @@ mod tests {
             setup_swap_announced(&who);
 
             for call in forbidden_calls() {
-                assert_eq!(
-                    call.dispatch(RuntimeOrigin::signed(who)).unwrap_err().error,
-                    Error::<Test>::ColdkeySwapAnnounced.into()
+                assert_noop!(
+                    call.dispatch(RuntimeOrigin::signed(who)),
+                    Error::<Test>::ColdkeySwapAnnounced
                 );
             }
         });
@@ -228,9 +233,9 @@ mod tests {
                 .collect::<Vec<_>>();
 
             for call in all_calls {
-                assert_eq!(
-                    call.dispatch(RuntimeOrigin::signed(who)).unwrap_err().error,
-                    Error::<Test>::ColdkeySwapDisputed.into()
+                assert_noop!(
+                    call.dispatch(RuntimeOrigin::signed(who)),
+                    Error::<Test>::ColdkeySwapDisputed
                 );
             }
         });