fix: change namespace char set

Author: saiintbrisson

.github/workflows/build-runtime.yml

@@ -37,7 +37,13 @@ jobs:
 
       - name: Build runtime
         run: |
-          cargo build --release --timings --package torus-runtime
+          if [[ "${{ github.ref }}" == refs/tags/runtime/testnet* ]]; then
+            echo "Building with testnet feature flag"
+            cargo build --release --timings --package torus-runtime --features testnet
+          else
+            echo "Building without testnet feature flag"
+            cargo build --release --timings --package torus-runtime
+          fi
 
           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 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/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/src/lib.rs

@@ -62,9 +62,10 @@ 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'.';
@@ -103,19 +104,22 @@ 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_alphabetic() && c.is_ascii_lowercase())
+                    && c != '-'
+                    && c != '_'
+                    && c != '+'
+            }) {
                 return Err("invalid character in namespace segment");
             }
         }
@@ -224,17 +228,23 @@ mod tests {
     #[test]
     fn namespace_creation_validates_paths() {
         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"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]

pallets/torus0/src/lib.rs

@@ -374,11 +374,6 @@ pub mod pallet {
                 Error::<T>::NamespacesFrozen
             );
 
-            ensure!(
-                Agents::<T>::contains_key(&owner),
-                Error::<T>::AgentDoesNotExist
-            );
-
             let namespace_path =
                 NamespacePath::new_agent(&path).map_err(|_| Error::<T>::InvalidNamespacePath)?;
 

pallets/torus0/src/migrations.rs

@@ -139,28 +139,51 @@ pub mod v5 {
             info!("created root agent namespace");
 
             for (id, agent) in Agents::<T>::iter() {
+                let old_name = agent.name.clone();
                 let Ok(agent_name) = core::str::from_utf8(&agent.name) else {
                     error!("agent name is not utf-8: {:?}", agent.name);
                     continue;
                 };
 
+                let agent_name = if cfg!(feature = "testnet") {
+                    agent_name.to_ascii_lowercase().replace(' ', "-")
+                } else {
+                    agent_name.into()
+                };
+
+                let Ok(bounded_name) = agent_name.as_bytes().to_vec().try_into() else {
+                    error!("cannot lower case agent {agent_name:?}");
+                    continue;
+                };
+
                 let path: polkadot_sdk::sp_std::vec::Vec<_> =
-                    [NAMESPACE_AGENT_PREFIX, &agent.name].concat();
+                    [NAMESPACE_AGENT_PREFIX, agent_name.as_bytes()].concat();
                 let path = match NamespacePath::new_agent(&path) {
                     Ok(path) => path,
                     Err(err) => {
-                        error!("cannot create path for agent {agent_name:?}: {err:?}");
+                        error!(
+                            "cannot create path for agent {agent_name:?} ({:?}): {err:?}",
+                            core::str::from_utf8(&path)
+                        );
                         continue;
                     }
                 };
 
+                Agents::<T>::mutate_extant(id.clone(), |agent| {
+                    agent.name = bounded_name;
+                });
+
                 #[allow(deprecated)]
                 if let Err(err) = crate::namespace::create_namespace0::<T>(
-                    NamespaceOwnership::Account(id),
+                    NamespaceOwnership::Account(id.clone()),
                     path.clone(),
                     false,
                 ) {
                     error!("cannot create namespace for agent {agent_name:?}: {err:?}");
+
+                    Agents::<T>::mutate_extant(id.clone(), |agent| {
+                        agent.name = old_name;
+                    });
                 } else {
                     info!("created namespace entry for agent {agent_name:?}: {path:?}");
                 }

pallets/torus0/src/namespace.rs

@@ -208,6 +208,16 @@ pub(crate) fn create_namespace0<T: Config>(
         Error::<T>::NamespaceAlreadyExists
     );
 
+    if let NamespaceOwnership::Account(owner) = &owner {
+        let path_agent = path
+            .segments()
+            .nth(1)
+            .ok_or(Error::<T>::InvalidNamespacePath)?;
+        let agent = Agents::<T>::get(owner).ok_or(Error::<T>::AgentDoesNotExist)?;
+
+        ensure!(path_agent == *agent.name, Error::<T>::InvalidNamespacePath);
+    }
+
     let missing_paths = find_missing_paths::<T>(&owner, &path);
 
     if charge {

runtime/Cargo.toml

@@ -56,7 +56,7 @@ try-runtime = [
     # Frontier
     "fp-self-contained/try-runtime",
 ]
-testnet = ["pallet-faucet/testnet"]
+testnet = ["pallet-torus0/testnet", "pallet-faucet/testnet"]
 
 [dependencies]
 serde_json = { workspace = true, features = ["alloc"] }