added restriction on uniquness of family names

Author: jstuczyn

common/cosmwasm-smart-contracts/node-families-contract/src/constants.rs

@@ -20,6 +20,8 @@ pub mod storage_keys {
     pub const FAMILIES_NAMESPACE: &str = "families";
     /// Secondary unique index keyed by `owner` (one family per owner).
     pub const FAMILIES_OWNER_IDX_NAMESPACE: &str = "families__owner";
+    /// Secondary unique index keyed by `name` (family names are globally unique).
+    pub const FAMILIES_NAME_IDX_NAMESPACE: &str = "families__name";
 
     /// Primary namespace for the pending invitations `IndexedMap`.
     pub const INVITATIONS_NAMESPACE: &str = "invitations";

contracts/node-families/src/helpers.rs

@@ -0,0 +1,16 @@
+// Copyright 2026 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+/// Normalise a family name into the canonical form used as the unique-index key.
+///
+/// Drops every character that isn't an ASCII letter or digit and lowercases
+/// the rest, so `"  Foo-Bar! "`, `"foobar"` and `"FOO BAR"` all collide on
+/// the storage layer's unique-name index. Callers should pass the normalised
+/// value to [`node_families_contract_common::NodeFamily::name`] when creating a family and when looking one
+/// up by name.
+pub fn normalise_family_name(name: &str) -> String {
+    name.chars()
+        .filter(|c| c.is_ascii_alphanumeric())
+        .map(|c| c.to_ascii_lowercase())
+        .collect()
+}

contracts/node-families/src/lib.rs

@@ -16,6 +16,7 @@ pub mod queued_migrations;
 /// `cw-storage-plus` definitions: typed maps, items and secondary indexes.
 pub mod storage;
 
+mod helpers;
 /// Read-only query handlers backing [`contract::query`].
 mod queries;
 /// Test-only helpers — only compiled when running the contract's unit tests.

contracts/node-families/src/storage/mod.rs

@@ -42,8 +42,10 @@ pub struct NodeFamiliesStorage<'a> {
     /// reserved as a "no family" sentinel.
     pub(crate) node_family_id_counter: Item<NodeFamilyId>,
 
-    /// All existing families, keyed by id, with a unique secondary index on
-    /// `owner` enforcing the **one-family-per-owner-address** invariant.
+    /// All existing families, keyed by id, with unique secondary indexes on
+    /// `owner` (one-family-per-owner-address) and on `name`
+    /// (family names are globally unique — compared by raw bytes, so
+    /// callers normalise upstream if case-insensitive uniqueness is desired).
     pub(crate) families: IndexedMap<NodeFamilyId, NodeFamily, NodeFamiliesIndex<'a>>,
 
     /// Mapping from a node id to the family it currently belongs to. A node
@@ -178,14 +180,16 @@ impl<'a> NodeFamiliesStorage<'a> {
     ///
     /// The caller (a transaction handler) is responsible for:
     /// - validating `name`, `description` and `owner`;
+    /// - normalising `name` (e.g. trim/lowercase) if case-insensitive
+    ///   uniqueness is desired — the storage layer compares raw bytes;
     /// - ensuring `owner` does not already own a family **and** is not
     ///   currently a member of one.
     ///
     /// Returns the freshly persisted [`NodeFamily`]. The underlying
-    /// `IndexedMap` enforces the one-family-per-owner invariant via the
-    /// unique index on `owner` as a defence-in-depth check, so this call
-    /// will fail if `owner` already owns a family — but the caller must not
-    /// rely on it for the membership check.
+    /// `IndexedMap` enforces the one-family-per-owner and unique-name
+    /// invariants via unique indexes on `owner` and `name` as a
+    /// defence-in-depth check, so this call will fail if either is already
+    /// taken — but the caller must not rely on it for the membership check.
     pub(crate) fn register_new_family(
         &self,
         store: &mut dyn Storage,
@@ -673,6 +677,34 @@ mod tests {
         assert_eq!(f2.id, 2);
     }
 
+    #[test]
+    fn register_new_family_rejects_duplicate_name() {
+        let mut tester = init_contract_tester();
+        let s = NodeFamiliesStorage::new();
+        let env = tester.env();
+        let alice = tester.addr_make("alice");
+        let bob = tester.addr_make("bob");
+
+        s.register_new_family(
+            tester.storage_mut(),
+            &env,
+            alice,
+            "shared".into(),
+            "".into(),
+        )
+        .unwrap();
+
+        // unique-index defence-in-depth check
+        let res = s.register_new_family(
+            tester.storage_mut(),
+            &env,
+            bob,
+            "shared".into(),
+            "".into(),
+        );
+        assert!(res.is_err());
+    }
+
     #[test]
     fn register_new_family_rejects_duplicate_owner() {
         let mut tester = init_contract_tester();

contracts/node-families/src/storage/storage_indexes.rs

@@ -10,11 +10,15 @@ use node_families_contract_common::{
 };
 use nym_mixnet_contract_common::NodeId;
 
-/// Secondary indexes over [`NodeFamily`]. Enforces one-family-per-owner via
-/// a `UniqueIndex` on the owner address.
+/// Secondary indexes over [`NodeFamily`]. Enforces one-family-per-owner and
+/// globally-unique family names via `UniqueIndex`es on `owner` and `name`.
 pub(crate) struct NodeFamiliesIndex<'a> {
     /// Unique index: at most one family per owner [`Addr`].
     pub(crate) owner: UniqueIndex<'a, Addr, NodeFamily, NodeFamilyId>,
+    /// Unique index: family names are globally unique. Compares by raw bytes —
+    /// callers must normalise (e.g. lowercase/trim) before insert if they
+    /// want case-insensitive uniqueness.
+    pub(crate) name: UniqueIndex<'a, String, NodeFamily, NodeFamilyId>,
 }
 
 impl<'a> NodeFamiliesIndex<'a> {
@@ -25,13 +29,18 @@ impl<'a> NodeFamiliesIndex<'a> {
                 |family| family.owner.clone(),
                 storage_keys::FAMILIES_OWNER_IDX_NAMESPACE,
             ),
+            name: UniqueIndex::new(
+                |family| family.name.clone(),
+                storage_keys::FAMILIES_NAME_IDX_NAMESPACE,
+            ),
         }
     }
 }
 
 impl IndexList<NodeFamily> for NodeFamiliesIndex<'_> {
     fn get_indexes(&'_ self) -> Box<dyn Iterator<Item = &'_ dyn Index<NodeFamily>> + '_> {
-        Box::new(std::iter::once(&self.owner as &dyn Index<NodeFamily>))
+        let v: Vec<&dyn Index<NodeFamily>> = vec![&self.owner, &self.name];
+        Box::new(v.into_iter())
     }
 }
 

contracts/node-families/src/testing.rs

@@ -117,14 +117,10 @@ pub trait NodeFamiliesContractTesterExt:
 
     fn make_family(&mut self, owner: &Addr) -> NodeFamily {
         let env = self.env();
+        // names must be globally unique; derive from owner addr (also unique)
+        let name = format!("family-{owner}");
         NodeFamiliesStorage::new()
-            .register_new_family(
-                self,
-                &env,
-                owner.clone(),
-                "dummy".to_string(),
-                "dummy".to_string(),
-            )
+            .register_new_family(self, &env, owner.clone(), name, "dummy".to_string())
             .unwrap()
     }