fix(namespaces): prevent de-registering root (#117)

This patch prevents a registered agent from de-registering the agent
entry (`agent.<name>`) through the `delete_namespace` extrinsic.

Author: saiintbrisson

flake.lock

@@ -1,3 +1,5 @@
+#![allow(clippy::result_large_err)]
+
 use std::{
     collections::BTreeMap,
     path::PathBuf,

node/src/cli/eth.rs

@@ -171,6 +171,6 @@ pub fn inherent_benchmark_data() -> Result<InherentData> {
     let timestamp = sp_timestamp::InherentDataProvider::new(d.into());
 
     futures::executor::block_on(timestamp.provide_inherent_data(&mut inherent_data))
-        .map_err(|e| format!("creating inherent data: {:?}", e))?;
+        .map_err(|e| format!("creating inherent data: {e:?}"))?;
     Ok(inherent_data)
 }

node/src/command/benchmarking.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::result_large_err)]
 //! The Torus node implementation.
 
 mod chain_spec;

node/src/main.rs

@@ -14,6 +14,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+#![allow(clippy::result_large_err)]
 
 use std::{pin::Pin, sync::Arc, time::Duration};
 

node/src/service.rs

@@ -204,9 +204,11 @@ impl<T: Config> ConsensusMemberInput<T> {
 
         let validator_permit = total_stake >= min_validator_stake && !weights.is_empty();
 
-        let weights = validator_permit
-            .then(|| Self::prepare_weights(weights, &agent_id))
-            .unwrap_or_default();
+        let weights = if validator_permit {
+            Self::prepare_weights(weights, &agent_id)
+        } else {
+            Default::default()
+        };
 
         ConsensusMemberInput {
             registered: <T::Torus>::is_agent_registered(&agent_id)

pallets/emission0/src/distribute.rs

@@ -82,6 +82,12 @@ impl NamespacePath {
         NamespacePath(b"agent".to_vec().try_into().unwrap())
     }
 
+    /// Create a new root agent namespace path from the agent name
+    pub fn new_agent_root(agent_name: &[u8]) -> Result<Self, &'static str> {
+        let namespace_path: Vec<_> = [NAMESPACE_AGENT_PREFIX, agent_name].concat();
+        Self::new_agent(&namespace_path)
+    }
+
     /// Create a new namespace path from bytes with validation
     pub fn new_agent(bytes: &[u8]) -> Result<Self, &'static str> {
         if bytes.is_empty() {
@@ -192,6 +198,19 @@ impl NamespacePath {
 
         parents
     }
+
+    /// Wether the namespace is an agent root path: "agent.<name>".
+    pub fn is_agent_root(&self) -> bool {
+        if self.depth() != 2 {
+            return false;
+        }
+
+        if let Some(root) = self.segments().next() {
+            root == b"agent"
+        } else {
+            false
+        }
+    }
 }
 
 impl Debug for NamespacePath {
@@ -293,4 +312,47 @@ mod tests {
         assert_eq!(parents[1].as_bytes(), b"agent.alice");
         assert_eq!(parents[2].as_bytes(), b"agent");
     }
+
+    #[test]
+    fn test_is_agent_root() {
+        let agent_alice = NamespacePath::new_agent(b"agent.alice").unwrap();
+        assert!(agent_alice.is_agent_root());
+
+        let agent_bob = NamespacePath::new_agent(b"agent.bob").unwrap();
+        assert!(agent_bob.is_agent_root());
+
+        let deeper = NamespacePath::new_agent(b"agent.alice.memory").unwrap();
+        assert!(!deeper.is_agent_root());
+
+        let just_agent = NamespacePath::agent_root();
+        assert!(!just_agent.is_agent_root());
+    }
+
+    #[test]
+    fn test_new_agent_root() {
+        let alice_root = NamespacePath::new_agent_root(b"alice").unwrap();
+        assert_eq!(alice_root.as_bytes(), b"agent.alice");
+        assert!(alice_root.is_agent_root());
+
+        let bob_root = NamespacePath::new_agent_root(b"bob").unwrap();
+        assert_eq!(bob_root.as_bytes(), b"agent.bob");
+        assert!(bob_root.is_agent_root());
+
+        assert!(NamespacePath::new_agent_root(b"alice123").is_ok());
+        assert!(NamespacePath::new_agent_root(b"alice-test").is_ok());
+        assert!(NamespacePath::new_agent_root(b"alice_test").is_ok());
+
+        assert!(
+            NamespacePath::new_agent_root(b"Alice").is_err(),
+            "uppercase should fail"
+        );
+        assert!(
+            NamespacePath::new_agent_root(b"alice!").is_err(),
+            "special chars should fail"
+        );
+        assert!(
+            NamespacePath::new_agent_root(b"").is_err(),
+            "empty name should fail"
+        );
+    }
 }

pallets/torus0/api/src/lib.rs

@@ -1,7 +1,7 @@
 use codec::{Decode, Encode, MaxEncodedLen};
 use pallet_emission0_api::Emission0Api;
 use pallet_governance_api::GovernanceApi;
-use pallet_torus0_api::{NamespacePath, NAMESPACE_AGENT_PREFIX};
+use pallet_torus0_api::NamespacePath;
 use polkadot_sdk::{
     frame_election_provider_support::Get,
     frame_support::{
@@ -78,8 +78,7 @@ pub fn register<T: crate::Config>(
         crate::Error::<T>::TooManyAgentRegistrationsThisInterval
     );
 
-    let namespace_path: Vec<_> = [NAMESPACE_AGENT_PREFIX, &name].concat();
-    let namespace_path = NamespacePath::new_agent(&namespace_path).map_err(|err| {
+    let namespace_path = NamespacePath::new_agent_root(&name).map_err(|err| {
         warn!("{agent_key:?} tried using invalid name: {err:?}");
         crate::Error::<T>::InvalidNamespacePath
     })?;
@@ -140,8 +139,7 @@ pub fn unregister<T: crate::Config>(agent_key: AccountIdOf<T>) -> DispatchResult
 
     let agent = crate::Agents::<T>::get(&agent_key).ok_or(crate::Error::<T>::AgentDoesNotExist)?;
 
-    let namespace_path: Vec<_> = [NAMESPACE_AGENT_PREFIX, &agent.name].concat();
-    let namespace_path = NamespacePath::new_agent(&namespace_path)
+    let namespace_path = NamespacePath::new_agent_root(&agent.name)
         .map_err(|_| crate::Error::<T>::InvalidNamespacePath)?;
     crate::namespace::delete_namespace::<T>(
         crate::namespace::NamespaceOwnership::Account(agent_key.clone()),

pallets/torus0/src/agent.rs

@@ -390,8 +390,8 @@ pub mod pallet {
                 NamespacePath::new_agent(&path).map_err(|_| Error::<T>::InvalidNamespacePath)?;
 
             ensure!(
-                !T::Permission0::is_delegating_namespace(&owner, &namespace_path),
-                Error::<T>::NamespaceBeingDelegated
+                !namespace_path.is_agent_root(),
+                Error::<T>::InvalidNamespacePath
             );
 
             namespace::delete_namespace::<T>(NamespaceOwnership::Account(owner), namespace_path)

pallets/torus0/src/lib.rs

@@ -64,7 +64,7 @@ pub mod v4 {
 }
 
 pub mod v5 {
-    use pallet_torus0_api::{NamespacePath, NAMESPACE_AGENT_PREFIX};
+    use pallet_torus0_api::NamespacePath;
     use polkadot_sdk::{
         frame_support::{migrations::VersionedMigration, traits::UncheckedOnRuntimeUpgrade},
         sp_tracing::{error, info},
@@ -138,15 +138,10 @@ pub mod v5 {
                     continue;
                 };
 
-                let path: polkadot_sdk::sp_std::vec::Vec<_> =
-                    [NAMESPACE_AGENT_PREFIX, agent_name.as_bytes()].concat();
-                let path = match NamespacePath::new_agent(&path) {
+                let path = match NamespacePath::new_agent_root(agent_name.as_bytes()) {
                     Ok(path) => path,
                     Err(err) => {
-                        error!(
-                            "cannot create path for agent {agent_name:?} ({:?}): {err:?}",
-                            core::str::from_utf8(&path)
-                        );
+                        error!("cannot create path for agent {agent_name:?}: {err:?}");
                         continue;
                     }
                 };