feat(torus0): dont change root namespace fee

Author: saiintbrisson

pallets/torus0/src/namespace.rs

@@ -60,6 +60,10 @@ impl<T: Config> NamespacePricingConfig<T> {
         &self,
         account_namespace_count: u32,
     ) -> Result<BalanceOf<T>, polkadot_sdk::sp_runtime::DispatchError> {
+        if account_namespace_count == 0 {
+            return Ok(Zero::zero());
+        }
+
         let Self {
             base_fee,
             count_midpoint,
@@ -95,6 +99,10 @@ impl<T: Config> NamespacePricingConfig<T> {
     /// is provided and contains more segments, the prefix (agent literal and agent name)
     /// will be dropped.
     pub fn namespace_deposit(&self, path: &NamespacePath) -> BalanceOf<T> {
+        if path.is_agent_root() {
+            return Zero::zero();
+        }
+
         self.deposit_per_byte
             .saturating_mul((path.as_bytes().len() as u32).into())
     }
@@ -243,14 +251,17 @@ pub(crate) fn create_namespace0<T: Config>(
         };
 
         Namespaces::<T>::insert(&owner, path, metadata);
+
+        Pallet::<T>::deposit_event(Event::NamespaceCreated {
+            owner: owner.clone(),
+            path: path.clone(),
+        });
     }
 
     NamespaceCount::<T>::mutate(&owner, |count| {
         *count = count.saturating_add(missing_paths.len() as u32)
     });
 
-    Pallet::<T>::deposit_event(Event::NamespaceCreated { owner, path });
-
     Ok(())
 }
 
@@ -286,6 +297,10 @@ pub fn delete_namespace<T: Config>(
     for (path_to_delete, deposit) in namespaces_to_delete {
         total_deposit = total_deposit.saturating_add(deposit);
         Namespaces::<T>::remove(&owner, &path_to_delete);
+        Pallet::<T>::deposit_event(Event::NamespaceDeleted {
+            owner: owner.clone(),
+            path: path_to_delete.clone(),
+        });
     }
 
     NamespaceCount::<T>::mutate(&owner, |count| *count = count.saturating_sub(deleted_count));
@@ -294,7 +309,5 @@ pub fn delete_namespace<T: Config>(
         T::Currency::unreserve(owner, total_deposit);
     }
 
-    Pallet::<T>::deposit_event(Event::NamespaceDeleted { owner, path });
-
     Ok(())
 }

pallets/torus0/tests/namespace.rs

@@ -9,28 +9,21 @@ use polkadot_sdk::{
 };
 use test_utils::{
     as_tors, get_origin, new_test_ext, pallet_governance, pallet_permission0::Permissions,
-    Balances, Test,
+    Balances, Test, Torus0,
 };
 
 /// Helper function to register an agent with a specific name and balance
 fn register_agent_with(account_id: u32, name: &str, balance: u128) {
-    // Register the agent with the specified name
-    pallet_torus0::Agents::<Test>::set(
-        account_id,
-        Some(pallet_torus0::agent::Agent {
-            key: account_id,
-            name: name.as_bytes().to_vec().try_into().unwrap(),
-            url: Default::default(),
-            metadata: Default::default(),
-            weight_penalty_factor: Default::default(),
-            registration_block: <polkadot_sdk::frame_system::Pallet<Test>>::block_number(),
-            fees: Default::default(),
-            last_update_block: Default::default(),
-        }),
-    );
-
     // Set the balance for the account
     let _ = Balances::deposit_creating(&account_id, balance);
+    let name = name.as_bytes().to_vec();
+    Torus0::register_agent(
+        get_origin(account_id),
+        name.clone(),
+        name.clone(),
+        name.clone(),
+    )
+    .unwrap();
 }
 
 fn set_namespace_config() {
@@ -155,7 +148,7 @@ fn namespace_fee_zero_steepness() {
 
         // steepness is 0, so always expect midpoint
         let expected = 1000 + 1000;
-        assert_eq!(fee_0, expected);
+        assert_eq!(fee_0, 0);
         assert_eq!(fee_10, expected);
         assert_eq!(fee_20, expected);
     });
@@ -239,9 +232,9 @@ fn namespace_deposit_basic() {
             max_fee_multiplier: 100,
         };
 
-        // The simple agent path
+        // The root agent path has no deposit requirement
         let path_agent = "agent.alice".parse().unwrap();
-        assert_eq!(config.namespace_deposit(&path_agent), 1100);
+        assert_eq!(config.namespace_deposit(&path_agent), 0);
 
         // Single character
         let path_a = "agent.alice.a".parse().unwrap();
@@ -340,7 +333,7 @@ fn namespace_fee_precision_handling() {
         let fee_1 = config.namespace_fee(1).unwrap();
         let fee_2 = config.namespace_fee(2).unwrap();
 
-        assert!(fee_0 > as_tors(1));
+        assert_eq!(fee_0, 0);
         assert!(fee_1 > fee_0);
         assert!(fee_2 > fee_1);
     });
@@ -534,6 +527,7 @@ fn calculate_cost_no_existing_namespaces() {
         test_utils::register_empty_agent(owner);
 
         let paths: &[NamespacePath] = &[
+            "agent.alice".parse().unwrap(),
             "agent.alice.v1".parse().unwrap(),
             "agent.alice.v1.compute".parse().unwrap(),
             "agent.alice.v1.compute.gpu".parse().unwrap(),
@@ -763,7 +757,7 @@ fn namespace_must_start_with_agent_prefix() {
         // Verify that a valid namespace starting with "agent." works
         assert_ok!(pallet_torus0::Pallet::<Test>::create_namespace(
             get_origin(0),
-            BoundedVec::truncate_from(b"agent.alice".to_vec())
+            BoundedVec::truncate_from(b"agent.alice.bla".to_vec())
         ));
     });
 }
@@ -776,13 +770,13 @@ fn create_namespace_simple() {
 
         assert_ok!(pallet_torus0::Pallet::<Test>::create_namespace(
             get_origin(0),
-            BoundedVec::truncate_from(b"agent.alice".to_vec())
+            BoundedVec::truncate_from(b"agent.alice.a".to_vec())
         ));
 
         // Verify namespace was created
         assert!(pallet_torus0::Namespaces::<Test>::contains_key(
             pallet_torus0::namespace::NamespaceOwnership::Account(0),
-            pallet_torus0_api::NamespacePath::new_agent(b"agent.alice").unwrap()
+            pallet_torus0_api::NamespacePath::new_agent(b"agent.alice.a").unwrap()
         ));
     });
 }
@@ -830,11 +824,11 @@ fn create_namespace_already_exists() {
         };
 
         // Create namespace first time
-        assert_ok!(create_namespace(b"agent.alice"));
+        assert_ok!(create_namespace(b"agent.alice.a"));
 
         // Try to create same namespace again
         assert_err!(
-            create_namespace(b"agent.alice"),
+            create_namespace(b"agent.alice.a"),
             pallet_torus0::Error::<Test>::NamespaceAlreadyExists
         );
     });
@@ -882,7 +876,7 @@ fn create_namespace_insufficient_balance() {
         assert_err!(
             pallet_torus0::Pallet::<Test>::create_namespace(
                 get_origin(0),
-                BoundedVec::truncate_from(b"agent.alice".to_vec())
+                BoundedVec::truncate_from(b"agent.alice.b".to_vec())
             ),
             pallet_balances::Error::<Test>::InsufficientBalance
         );