refac(torus0/namespace): require agent prefix

This change makes the "agent.<name>" prefix required in order to facilitate
future integrations. This change, though, makes the agent name immutable.
Now, upon registration, the agent name will be automatically registered
to the namespace.

Closes CHAIN-102.

Author: saiintbrisson

pallets/permission0/src/ext/namespace_impl.rs

@@ -45,7 +45,8 @@ pub fn grant_namespace_permission_impl<T: Config>(
     let paths = paths
         .into_iter()
         .map(|path| {
-            let path = NamespacePath::new(&path).map_err(|_| Error::<T>::NamespacePathIsInvalid)?;
+            let path =
+                NamespacePath::new_agent(&path).map_err(|_| Error::<T>::NamespacePathIsInvalid)?;
             ensure!(
                 T::Torus::namespace_exists(&grantor, &path),
                 Error::<T>::NamespaceDoesNotExist

pallets/torus0/api/Cargo.toml

@@ -18,4 +18,9 @@ try-runtime = ["polkadot-sdk/try-runtime"]
 [dependencies]
 codec = { workspace = true, features = ["derive"] }
 scale-info = { workspace = true, features = ["derive"] }
-polkadot-sdk = { workspace = true, features = ["sp-runtime"] }
+polkadot-sdk = { workspace = true, features = [
+    "sp-api",
+    "sp-core",
+    "sp-runtime",
+    "sp-std",
+] }

pallets/torus0/api/src/lib.rs

@@ -68,15 +68,21 @@ pub const MAX_SEGMENT_LENGTH: usize = 64;
 pub const MAX_NAMESPACE_SEGMENTS: usize = 10;
 
 pub const NAMESPACE_SEPARATOR: u8 = b'.';
+pub const NAMESPACE_AGENT_PREFIX: &[u8] = b"agent.";
 
 pub type NamespacePathInner = BoundedVec<u8, ConstU32<{ MAX_NAMESPACE_PATH_LENGTH as u32 }>>;
 
 #[derive(Encode, Decode, Clone, PartialEq, Eq, PartialOrd, Ord, TypeInfo, MaxEncodedLen)]
 pub struct NamespacePath(NamespacePathInner);
 
 impl NamespacePath {
+    /// The root agent namespace entry.
+    pub fn agent_root() -> NamespacePath {
+        NamespacePath(b"agent".to_vec().try_into().unwrap())
+    }
+
     /// Create a new namespace path from bytes with validation
-    pub fn new(bytes: &[u8]) -> Result<Self, &'static str> {
+    pub fn new_agent(bytes: &[u8]) -> Result<Self, &'static str> {
         if bytes.is_empty() {
             return Err("empty namespace path");
         }
@@ -85,6 +91,10 @@ impl NamespacePath {
             return Err("path too long");
         }
 
+        if !bytes.starts_with(NAMESPACE_AGENT_PREFIX) {
+            return Err("path must begin with agent prefix");
+        }
+
         let segments: Vec<&[u8]> = bytes.split(|&b| b == NAMESPACE_SEPARATOR).collect();
         if segments.len() > MAX_NAMESPACE_SEGMENTS {
             return Err("too many namespace segments");
@@ -128,10 +138,17 @@ impl NamespacePath {
     }
 
     /// Parse a namespace path into segments
-    pub fn segments(&self) -> Vec<&[u8]> {
-        self.as_bytes()
-            .split(|&b| b == NAMESPACE_SEPARATOR)
-            .collect()
+    pub fn segments(&self) -> impl Iterator<Item = &[u8]> {
+        self.as_bytes().split(|&b| b == NAMESPACE_SEPARATOR)
+    }
+
+    /// Returns the first segment of the path.
+    pub fn root(&self) -> Option<Self> {
+        let Some(root) = self.as_bytes().split(|&b| b == NAMESPACE_SEPARATOR).next() else {
+            return Some(self.clone());
+        };
+
+        root.to_vec().try_into().ok().map(Self)
     }
 
     /// Get the parent path of this namespace
@@ -147,7 +164,7 @@ impl NamespacePath {
 
     /// Get the depth of this namespace (number of segments)
     pub fn depth(&self) -> u32 {
-        self.segments().len() as u32
+        self.segments().count() as u32
     }
 
     /// Check if this path is a parent of another path
@@ -194,7 +211,7 @@ impl FromStr for NamespacePath {
     type Err = &'static str;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::new(s.as_bytes())
+        Self::new_agent(s.as_bytes())
     }
 }
 
@@ -206,54 +223,54 @@ mod tests {
 
     #[test]
     fn namespace_creation_validates_paths() {
-        assert!(NamespacePath::new(b"agent").is_ok());
-        assert!(NamespacePath::new(b"agent.alice").is_ok());
-        assert!(NamespacePath::new(b"agent.alice.memory").is_ok());
-        assert!(NamespacePath::new(b"agent-1.alice_2.key=val+1").is_ok());
-
-        assert!(NamespacePath::new(b"").is_err());
-        assert!(NamespacePath::new(b".agent").is_err());
-        assert!(NamespacePath::new(b"agent.").is_err());
-        assert!(NamespacePath::new(b"agent..alice").is_err());
-        assert!(NamespacePath::new(b"agent.-alice").is_err());
-        assert!(NamespacePath::new(b"agent.alice!").is_err());
-        assert!(NamespacePath::new(b"agent.alice memory").is_err());
+        assert!(NamespacePath::new_agent(b"agent.alice").is_ok());
+        assert!(NamespacePath::new_agent("agent.alice.tørûs".as_bytes()).is_ok());
+        assert!(NamespacePath::new_agent(b"agent.alice_2.memory-1.key=val+1").is_ok());
+
+        assert!(NamespacePath::new_agent(b"").is_err());
+        assert!(NamespacePath::new_agent(b"agent").is_err());
+        assert!(NamespacePath::new_agent(b".agent").is_err());
+        assert!(NamespacePath::new_agent(b"agent.").is_err());
+        assert!(NamespacePath::new_agent(b"agent..alice").is_err());
+        assert!(NamespacePath::new_agent(b"agent.-alice").is_err());
+        assert!(NamespacePath::new_agent(b"agent.alice!").is_err());
+        assert!(NamespacePath::new_agent(b"agent.alice memory").is_err());
     }
 
     #[test]
     fn namespace_segment_listing() {
-        let path = NamespacePath::new(b"agent.alice.memory").unwrap();
-        let segments = path.segments();
-        assert_eq!(segments.len(), 3);
-        assert_eq!(segments[0], b"agent");
-        assert_eq!(segments[1], b"alice");
-        assert_eq!(segments[2], b"memory");
+        let path = NamespacePath::new_agent(b"agent.alice.memory").unwrap();
+        let mut segments = path.segments();
+        assert_eq!(segments.next(), Some(b"agent".as_slice()));
+        assert_eq!(segments.next(), Some(b"alice".as_slice()));
+        assert_eq!(segments.next(), Some(b"memory".as_slice()));
+        assert_eq!(segments.next(), None);
     }
 
     #[test]
     fn namespace_parent_returns_correctly() {
-        let path = NamespacePath::new(b"agent.alice.memory").unwrap();
+        let path = NamespacePath::new_agent(b"agent.alice.memory").unwrap();
         let parent = path.parent().unwrap();
         assert_eq!(parent.as_bytes(), b"agent.alice");
 
-        let root = NamespacePath::new(b"agent").unwrap();
+        let root = NamespacePath::agent_root();
         assert!(root.parent().is_none());
     }
 
     #[test]
     fn namespace_depth_calculation() {
-        let path1 = NamespacePath::new(b"agent").unwrap();
-        assert_eq!(path1.depth(), 1);
+        let path1 = NamespacePath::new_agent(b"agent.alice").unwrap();
+        assert_eq!(path1.depth(), 2);
 
-        let path2 = NamespacePath::new(b"agent.alice.memory.twitter").unwrap();
+        let path2 = NamespacePath::new_agent(b"agent.alice.memory.twitter").unwrap();
         assert_eq!(path2.depth(), 4);
     }
 
     #[test]
     fn test_is_parent_of() {
-        let parent = NamespacePath::new(b"agent.alice").unwrap();
-        let child = NamespacePath::new(b"agent.alice.memory").unwrap();
-        let other = NamespacePath::new(b"agent.bob").unwrap();
+        let parent = NamespacePath::new_agent(b"agent.alice").unwrap();
+        let child = NamespacePath::new_agent(b"agent.alice.memory").unwrap();
+        let other = NamespacePath::new_agent(b"agent.bob").unwrap();
 
         assert!(parent.is_parent_of(&child));
         assert!(!parent.is_parent_of(&other));
@@ -262,7 +279,7 @@ mod tests {
 
     #[test]
     fn test_parents() {
-        let path = NamespacePath::new(b"agent.alice.memory.twitter").unwrap();
+        let path = NamespacePath::new_agent(b"agent.alice.memory.twitter").unwrap();
         let parents = path.parents();
         assert_eq!(parents.len(), 3);
         assert_eq!(parents[0].as_bytes(), b"agent.alice.memory");

pallets/torus0/src/agent.rs

@@ -1,6 +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 polkadot_sdk::{
     frame_election_provider_support::Get,
     frame_support::{
@@ -11,7 +12,7 @@ use polkadot_sdk::{
     },
     polkadot_sdk_frame::prelude::BlockNumberFor,
     sp_runtime::{traits::Saturating, BoundedVec, DispatchError, Percent},
-    sp_tracing::debug_span,
+    sp_tracing::{debug_span, warn},
 };
 use scale_info::{prelude::vec::Vec, TypeInfo};
 
@@ -77,7 +78,12 @@ pub fn register<T: crate::Config>(
         crate::Error::<T>::TooManyAgentRegistrationsThisInterval
     );
 
-    validate_agent_name::<T>(&name[..])?;
+    let namespace_path: Vec<_> = [NAMESPACE_AGENT_PREFIX, &name].concat();
+    let namespace_path = NamespacePath::new_agent(&namespace_path).map_err(|err| {
+        warn!("{agent_key:?} tried using invalid name: {err:?}");
+        crate::Error::<T>::InvalidNamespacePath
+    })?;
+
     validate_agent_url::<T>(&url[..])?;
     validate_agent_metadata::<T>(&metadata[..])?;
 
@@ -107,6 +113,11 @@ pub fn register<T: crate::Config>(
         },
     );
 
+    crate::namespace::create_namespace::<T>(
+        crate::namespace::NamespaceOwnership::Account(agent_key.clone()),
+        namespace_path,
+    )?;
+
     crate::RegistrationsThisBlock::<T>::mutate(|value| value.saturating_add(1));
     crate::RegistrationsThisInterval::<T>::mutate(|value| value.saturating_add(1));
 
@@ -127,10 +138,15 @@ pub fn unregister<T: crate::Config>(agent_key: AccountIdOf<T>) -> DispatchResult
     let span = debug_span!("unregister", agent.key = ?agent_key);
     let _guard = span.enter();
 
-    ensure!(
-        exists::<T>(&agent_key),
-        crate::Error::<T>::AgentDoesNotExist
-    );
+    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)
+        .map_err(|_| crate::Error::<T>::InvalidNamespacePath)?;
+    crate::namespace::delete_namespace::<T>(
+        crate::namespace::NamespaceOwnership::Account(agent_key.clone()),
+        namespace_path,
+    )?;
 
     crate::Agents::<T>::remove(&agent_key);
     crate::stake::clear_key::<T>(&agent_key)?;
@@ -143,7 +159,6 @@ pub fn unregister<T: crate::Config>(agent_key: AccountIdOf<T>) -> DispatchResult
 /// Updates the metadata of an existing agent.
 pub fn update<T: crate::Config>(
     agent_key: AccountIdOf<T>,
-    name: Vec<u8>,
     url: Vec<u8>,
     metadata: Option<Vec<u8>>,
     staking_fee: Option<Percent>,
@@ -161,9 +176,6 @@ pub fn update<T: crate::Config>(
             return Err(crate::Error::<T>::AgentUpdateOnCooldown.into());
         }
 
-        validate_agent_name::<T>(&name[..])?;
-        agent.name = BoundedVec::truncate_from(name);
-
         validate_agent_url::<T>(&url[..])?;
         agent.url = BoundedVec::truncate_from(url);
 
@@ -228,31 +240,6 @@ pub fn exists<T: crate::Config>(key: &AccountIdOf<T>) -> bool {
     crate::Agents::<T>::contains_key(key)
 }
 
-fn validate_agent_name<T: crate::Config>(bytes: &[u8]) -> DispatchResult {
-    let len: u32 = bytes
-        .len()
-        .try_into()
-        .map_err(|_| crate::Error::<T>::AgentNameTooLong)?;
-
-    ensure!(
-        len >= crate::MinNameLength::<T>::get() as u32,
-        crate::Error::<T>::AgentNameTooShort
-    );
-
-    ensure!(
-        len <= (crate::MaxNameLength::<T>::get() as u32)
-            .min(T::MaxAgentNameLengthConstraint::get()),
-        crate::Error::<T>::AgentNameTooLong
-    );
-
-    ensure!(
-        core::str::from_utf8(bytes).is_ok(),
-        crate::Error::<T>::InvalidAgentName
-    );
-
-    Ok(())
-}
-
 fn validate_agent_url<T: crate::Config>(bytes: &[u8]) -> DispatchResult {
     let len: u32 = bytes
         .len()

pallets/torus0/src/benchmarking.rs

@@ -109,7 +109,6 @@ mod benchmarks {
 
         AgentUpdateCooldown::<T>::set(Default::default());
 
-        let name = vec![4, 5, 6];
         let url = vec![4, 5, 6];
         let metadata = Some(vec![4, 5, 6]);
         let staking_fee = Some(Percent::from_percent(10));
@@ -118,7 +117,6 @@ mod benchmarks {
         #[extrinsic_call]
         update_agent(
             RawOrigin::Signed(agent),
-            name,
             url,
             metadata,
             staking_fee,