chore: add rpc

Author: saiintbrisson

pallets/permission0/api/src/lib.rs

@@ -192,5 +192,8 @@ polkadot_sdk::sp_api::decl_runtime_apis! {
         /// The root stream ID is assigned by the system when emitting
         /// tokens from the STAKE as rewards.
         fn root_stream_id_for_account(account_id: AccountId) -> StreamId;
+
+        /// Calculates the number of available instances for a given path.
+        fn available_namespace_instances(permission_id: PermissionId, path: pallet_torus0_api::NamespacePathInner) -> Result<u32, DispatchError> ;
     }
 }

pallets/permission0/src/permission/namespace.rs

@@ -3,6 +3,7 @@ use pallet_torus0_api::NamespacePath;
 use polkadot_sdk::{
     frame_support::{CloneNoBound, DebugNoBound, dispatch::DispatchResult},
     sp_runtime::{BoundedBTreeMap, BoundedBTreeSet},
+    sp_std::vec::Vec,
 };
 use scale_info::TypeInfo;
 
@@ -28,22 +29,8 @@ pub struct NamespaceScope<T: Config> {
 }
 
 impl<T: Config> NamespaceScope<T> {
-    /// Checks that the provided paths are allowed to be delegated.
-    /// This is true if enough instances are available and unused by
-    /// sibilings.
-    ///
-    /// Given a subpath, an instance is used if any parent or child
-    /// paths from that subpath were delegated to a sibiling permission.
-    /// Sibiling subpaths do not consume an instance relative to this
-    /// subpath.
-    pub(crate) fn check_available_instances<'a>(
-        &self,
-        this_id: PermissionId,
-        other: impl Iterator<Item = &'a NamespacePath>,
-        instances: u32,
-    ) -> DispatchResult {
-        let mut sibiling_paths = self
-            .children
+    fn sibiling_paths(&self, this_id: PermissionId) -> impl Iterator<Item = (NamespacePath, u32)> {
+        self.children
             .iter()
             .filter_map(|c| {
                 if let PermissionScope::Namespace(sibiling) = Permissions::<T>::get(c)?.scope {
@@ -52,25 +39,44 @@ impl<T: Config> NamespaceScope<T> {
                     None
                 }
             })
-            .flat_map(|sibiling| {
+            .flat_map(move |sibiling| {
                 sibiling
                     .paths
                     .into_iter()
-                    .filter(|(pid, _)| pid.as_ref().is_some_and(|pid| pid == &this_id))
+                    .filter(move |(pid, _)| pid.as_ref().is_some_and(|pid| pid == &this_id))
                     .flat_map(|(_, paths)| paths)
                     .map(move |path| (path, sibiling.max_instances))
             })
-            .collect::<polkadot_sdk::sp_std::vec::Vec<_>>();
+    }
+
+    /// Checks that the provided paths are allowed to be delegated.
+    /// This is true if enough instances are available and unused by
+    /// sibilings.
+    ///
+    /// Given a subpath, an instance is used if any parent or child
+    /// paths from that subpath were delegated to a sibiling permission.
+    /// Sibiling subpaths do not consume an instance relative to this
+    /// subpath.
+    pub(crate) fn check_available_instances<'a>(
+        &self,
+        this_id: PermissionId,
+        other: impl Iterator<Item = &'a NamespacePath>,
+        instances: u32,
+    ) -> DispatchResult {
+        let mut sibiling_paths: Vec<_> = self.sibiling_paths(this_id).collect();
 
         for other in other {
-            let mut used_instances = 0u32;
+            let mut available_instances = self.max_instances;
 
             for (sibiling_path, max_instances) in &sibiling_paths {
                 if sibiling_path == other
                     || sibiling_path.is_parent_of(other)
                     || other.is_parent_of(sibiling_path)
                 {
-                    used_instances = used_instances.saturating_add(*max_instances);
+                    available_instances = available_instances.saturating_sub(*max_instances);
+                    if available_instances < instances {
+                        return Err(Error::<T>::NotEnoughInstances.into());
+                    }
                 }
             }
 
@@ -86,14 +92,33 @@ impl<T: Config> NamespaceScope<T> {
             // Earlier paths are sibilings to later paths.
             sibiling_paths.push((other.clone(), instances));
 
-            if self.max_instances.saturating_sub(used_instances) < instances {
+            if available_instances < instances {
                 return Err(Error::<T>::NotEnoughInstances.into());
             }
         }
 
         Ok(())
     }
 
+    /// Count the number of available instances for a given path.
+    pub fn available_instances(&self, this_id: PermissionId, path: &NamespacePath) -> u32 {
+        let mut available_instances = self.max_instances;
+
+        for (sibiling_path, max_instances) in self.sibiling_paths(this_id) {
+            if &sibiling_path == path
+                || sibiling_path.is_parent_of(path)
+                || path.is_parent_of(&sibiling_path)
+            {
+                available_instances = available_instances.saturating_sub(max_instances);
+                if available_instances == 0 {
+                    return 0;
+                }
+            }
+        }
+
+        available_instances
+    }
+
     /// Cleanup operations when permission is revoked or expired
     pub(super) fn cleanup(
         &self,

runtime/src/apis.rs

@@ -470,6 +470,25 @@ impl_runtime_apis! {
         fn root_stream_id_for_account(account_id: AccountId) -> StreamId {
             generate_root_stream_id(&account_id)
         }
+
+        fn available_namespace_instances(
+            permission_id: pallet_permission0_api::PermissionId,
+            path: pallet_torus0_api::NamespacePathInner
+        ) -> Result<u32, DispatchError> {
+            use pallet_permission0::Permissions;
+            use pallet_torus0_api::NamespacePath;
+
+            let namespace_path =
+                NamespacePath::new_agent(&path).map_err(|_| pallet_torus0::Error::<Runtime>::InvalidNamespacePath)?;
+
+            let permission =
+                Permissions::<Runtime>::get(permission_id).ok_or(pallet_permission0::Error::<Runtime>::PermissionNotFound)?;
+            let pallet_permission0::PermissionScope::Namespace(scope) = &permission.scope else {
+                return Err(pallet_permission0::Error::<Runtime>::UnsupportedPermissionType.into());
+            };
+
+            Ok(scope.available_instances(permission_id, &namespace_path))
+         }
     }
 
     impl pallet_torus0_api::api::Torus0RuntimeApi<Block, AccountId, Balance> for Runtime {
@@ -480,7 +499,7 @@ impl_runtime_apis! {
             let namespace_path =
                 NamespacePath::new_agent(&path).map_err(|_| pallet_torus0::Error::<Runtime>::InvalidNamespacePath)?;
 
-                let owner = namespace::NamespaceOwnership::Account(account_id);
+            let owner = namespace::NamespaceOwnership::Account(account_id);
             let missing_paths = namespace::find_missing_paths::<Runtime>(&owner, &namespace_path);
             namespace::calculate_cost::<Runtime>(&owner, &missing_paths)
         }