refac(torus0/namespace): require agent prefix (#111)

Author: saiintbrisson

.github/workflows/build-runtime.yml

@@ -37,7 +37,8 @@ jobs:
 
       - name: Build runtime
         run: |
-          cargo build --release --timings --package torus-runtime
+          echo "Building ${{ startsWith(github.ref, 'refs/tags/runtime/testnet') && 'with testnet feature flag' || 'without testnet feature flag' }}"
+          cargo build --release --timings --package torus-runtime ${{ startsWith(github.ref, 'refs/tags/runtime/testnet') && '--features testnet' || '' }}
 
           export SHA256SUM=$(sha256sum target/release/wbuild/torus-runtime/torus_runtime.compact.compressed.wasm | cut -d ' ' -f1)
           echo Hash of compact and compressed WASM: $SHA256SUM

docs/namespace.md

@@ -23,7 +23,10 @@ The path validation ensures consistency across the network:
 - Maximum 255 bytes total length
 - Maximum 10 segments (depth limitation)
 - Each segment between 1-63 characters
-- Valid characters: unicode alphanumerics, `-`, `_`
+- Segments must begin and end with alphanumerics
+- Valid characters: ASCII alphanumerics, `-`, `_`, and `+`
+
+> Implementations MUST NOT assume the character set will be ASCII only forever. Paths are UTF-8 encoded strings.
 
 This structure creates clear ownership: `agent.alice` owns all paths under that prefix, from `agent.alice.api` to `agent.alice.memory.twitter.v2`. The depth limitation prevents excessive nesting while still allowing meaningful organization.
 

justfile

@@ -59,7 +59,7 @@ install-try-runtime:
   cargo install --git https://github.com/paritytech/try-runtime-cli --locked
 
 try-runtime-upgrade-testnet:
-    cargo build --release --features try-runtime
+    cargo build --release --features try-runtime,testnet
     RUST_BACKTRACE=1 RUST_LOG=info try-runtime --runtime target/release/wbuild/torus-runtime/torus_runtime.compact.compressed.wasm on-runtime-upgrade --blocktime 8000 live --uri wss://api.testnet.torus.network
 
 try-runtime-upgrade-mainnet:

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/Cargo.toml

@@ -25,7 +25,7 @@ runtime-benchmarks = [
     "pallet-torus0-api/runtime-benchmarks",
 ]
 try-runtime = ["polkadot-sdk/try-runtime", "pallet-torus0-api/try-runtime"]
-
+testnet = []
 
 [dependencies]
 codec = { workspace = true, features = ["derive"] }

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

@@ -62,21 +62,28 @@ pub trait Torus0Api<AccountId, Balance> {
 /// This might have to increase in the future, but is a good enough default value.
 /// If it ends up being formalized, the length can be described as a u8.
 pub const MAX_NAMESPACE_PATH_LENGTH: usize = 256;
-/// Number of total bytes a segment can contain.
-pub const MAX_SEGMENT_LENGTH: usize = 64;
-/// Max number of segments in a path.
+/// Number of total bytes a segment can contain. 63 plus dot.
+pub const MAX_SEGMENT_LENGTH: usize = 63;
+/// Max number of segments in a path. In the common prefix case, an agent will have
+/// up to 8 levels of depth to use, 2 being allocated to the agent prefix notation.
 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 +92,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");
@@ -93,19 +104,19 @@ impl NamespacePath {
         for segment in &segments {
             let segment = core::str::from_utf8(segment).map_err(|_| "path is invalid itf-8")?;
 
-            let first = segment.chars().next().ok_or("empty namespace segment")?;
-            if !first.is_alphanumeric() {
-                return Err("namespace segment must start with alphanumeric character");
-            }
-
             if segment.len() > MAX_SEGMENT_LENGTH {
                 return Err("namespace segment too long");
             }
 
-            if segment
-                .chars()
-                .any(|c| !c.is_alphanumeric() && c != '-' && c != '_' && c != '+' && c != '=')
-            {
+            let first = segment.chars().next().ok_or("empty namespace segment")?;
+            let last = segment.chars().last().ok_or("empty namespace segment")?;
+            if !first.is_ascii_alphanumeric() || !last.is_ascii_alphanumeric() {
+                return Err("namespace segment must start and end with alphanumeric characters");
+            }
+
+            if segment.chars().any(|c| {
+                !(c.is_ascii_digit() || c.is_ascii_lowercase()) && c != '-' && c != '_' && c != '+'
+            }) {
                 return Err("invalid character in namespace segment");
             }
         }
@@ -128,10 +139,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 +165,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 +212,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 +224,60 @@ 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(b"agent.alice_2.memory-1.func+1").is_ok());
+
+        assert!(NamespacePath::new_agent(format!("agent.alice.{:0<63}", 1).as_bytes()).is_ok());
+        assert!(NamespacePath::new_agent(format!("agent.alice.{:0<64}", 1).as_bytes()).is_err());
+
+        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-").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());
+        assert!(NamespacePath::new_agent("agent.alice.tørûs".as_bytes()).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 +286,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,