feat(namespace): cost calculation rpc (#106)

Adds a new RPC call, `torus0_namespacePathCreationCost`, that calculates
the total fee and deposit needed to create a new namespace entry.

Author: saiintbrisson

Cargo.lock

@@ -35,6 +35,7 @@ pallet-emission0-api = { path = "./pallets/emission0/api", default-features = fa
 pallet-faucet = { path = "./pallets/faucet", default-features = false }
 pallet-torus0 = { path = "./pallets/torus0", default-features = false }
 pallet-torus0-api = { path = "./pallets/torus0/api", default-features = false }
+pallet-torus0-rpc = { path = "./pallets/torus0/rpc", default-features = false }
 pallet-permission0 = { path = "./pallets/permission0", default-features = false }
 pallet-permission0-api = { path = "./pallets/permission0/api", default-features = false }
 pallet-permission0-rpc = { path = "./pallets/permission0/rpc", default-features = false }

Cargo.toml

@@ -107,6 +107,7 @@ fp-rpc = { workspace = true, features = ["default"] }
 # Local
 torus-runtime.workspace = true
 pallet-permission0-rpc.workspace = true
+pallet-torus0-rpc.workspace = true
 
 [build-dependencies]
 polkadot-sdk = { workspace = true, features = ["substrate-build-script-utils"] }

node/Cargo.toml

@@ -28,6 +28,7 @@ use eth::EthDeps;
 use futures::channel::mpsc;
 use jsonrpsee::RpcModule;
 use pallet_permission0_rpc::{Permission0Rpc, Permission0StreamApiServer};
+use pallet_torus0_rpc::{Torus0ApiServer, Torus0Rpc};
 use polkadot_sdk::{
     pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer},
     sc_consensus_manual_seal::{
@@ -86,7 +87,8 @@ where
 
     io.merge(System::new(client.clone(), pool).into_rpc())?;
     io.merge(TransactionPayment::new(client.clone()).into_rpc())?;
-    io.merge(Permission0Rpc::new(client).into_rpc())?;
+    io.merge(Permission0Rpc::new(client.clone()).into_rpc())?;
+    io.merge(Torus0Rpc::new(client.clone()).into_rpc())?;
 
     if let Some(command_sink) = command_sink {
         io.merge(

node/src/rpc.rs

@@ -0,0 +1,12 @@
+#![allow(clippy::multiple_bound_locations)]
+
+use codec::{Decode, Encode};
+use polkadot_sdk::sp_runtime::DispatchError;
+
+polkadot_sdk::sp_api::decl_runtime_apis! {
+    /// RPC related to Torus0.
+    pub trait Torus0RuntimeApi<AccountId: Encode, Balance: Decode> {
+        /// Calculates the total creation cost of a namespace: (Fee, Deposit).
+        fn namespace_path_creation_cost(account_id: AccountId, path: crate::NamespacePathInner) -> Result<(Balance, Balance), DispatchError>;
+    }
+}

pallets/torus0/api/src/api.rs

@@ -3,7 +3,10 @@
 extern crate alloc;
 extern crate polkadot_sdk;
 
-use core::str::FromStr;
+use core::{
+    fmt::{Debug, Display},
+    str::FromStr,
+};
 
 use codec::{Decode, Encode, MaxEncodedLen};
 use polkadot_sdk::{
@@ -13,6 +16,8 @@ use polkadot_sdk::{
 };
 use scale_info::TypeInfo;
 
+pub mod api;
+
 /// The Torus0 pallet API.
 pub trait Torus0Api<AccountId, Balance> {
     /// Interval of blocks in which rewards are distributed.
@@ -66,7 +71,7 @@ pub const NAMESPACE_SEPARATOR: u8 = b'.';
 
 pub type NamespacePathInner = BoundedVec<u8, ConstU32<{ MAX_NAMESPACE_PATH_LENGTH as u32 }>>;
 
-#[derive(Encode, Decode, Clone, PartialEq, Eq, PartialOrd, Ord, TypeInfo, MaxEncodedLen, Debug)]
+#[derive(Encode, Decode, Clone, PartialEq, Eq, PartialOrd, Ord, TypeInfo, MaxEncodedLen)]
 pub struct NamespacePath(NamespacePathInner);
 
 impl NamespacePath {
@@ -171,6 +176,20 @@ impl NamespacePath {
     }
 }
 
+impl Debug for NamespacePath {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("NamespacePath")
+            .field(&core::str::from_utf8(&self.0))
+            .finish()
+    }
+}
+
+impl Display for NamespacePath {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str(core::str::from_utf8(&self.0).unwrap_or("invalid path"))
+    }
+}
+
 impl FromStr for NamespacePath {
     type Err = &'static str;
 

pallets/torus0/api/src/lib.rs

@@ -0,0 +1,14 @@
+[package]
+name = "pallet-torus0-rpc"
+version = "0.1.0"
+edition = "2021"
+
+[lints]
+workspace = true
+
+[dependencies]
+async-trait.workspace = true
+jsonrpsee.workspace = true
+pallet-torus0-api = { workspace = true, features = ["std"] }
+polkadot-sdk = { workspace = true, features = ["sp-api", "sp-runtime", "std"] }
+torus-runtime = { workspace = true, features = ["std"] }

pallets/torus0/rpc/Cargo.toml

@@ -0,0 +1,68 @@
+use std::sync::Arc;
+
+use jsonrpsee::{core::RpcResult, types::ErrorObject};
+use pallet_torus0_api::{api::Torus0RuntimeApi, NamespacePathInner};
+use polkadot_sdk::{
+    sp_api::ProvideRuntimeApi,
+    sp_blockchain::HeaderBackend,
+    sp_runtime::{
+        traits::{IdentifyAccount, Verify},
+        MultiSignature,
+    },
+};
+use torus_runtime::opaque::Block;
+
+type Signature = MultiSignature;
+type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
+type Balance = u128;
+
+#[jsonrpsee::proc_macros::rpc(client, server)]
+pub trait Torus0Api {
+    #[method(name = "torus0_namespacePathCreationCost")]
+    async fn namespace_path_creation_cost(
+        &self,
+        account_id: AccountId,
+        path: NamespacePathInner,
+    ) -> RpcResult<(Balance, Balance)>;
+}
+
+pub struct Torus0Rpc<Client> {
+    client: Arc<Client>,
+}
+
+impl<Client> Torus0Rpc<Client> {
+    pub fn new(client: Arc<Client>) -> Self {
+        Self { client }
+    }
+}
+
+#[async_trait::async_trait]
+impl<Client> Torus0ApiServer for Torus0Rpc<Client>
+where
+    Client: ProvideRuntimeApi<Block> + HeaderBackend<Block> + Send + Sync + 'static,
+    Client::Api: Torus0RuntimeApi<Block, AccountId, Balance>,
+{
+    async fn namespace_path_creation_cost(
+        &self,
+        account_id: AccountId,
+        path: NamespacePathInner,
+    ) -> RpcResult<(Balance, Balance)> {
+        let runtime = &*self.client.runtime_api();
+        let at = self.client.info().best_hash;
+
+        runtime
+            .namespace_path_creation_cost(at, account_id, path)
+            .map(|res| {
+                res.map_err(|err| {
+                    ErrorObject::owned(
+                        1,
+                        "namespace cost calculation failed",
+                        Some(format!("{err:?}")),
+                    )
+                })
+            })
+            .map_err(|err| {
+                ErrorObject::owned(1, "Runtime execution failed", Some(err.to_string()))
+            })?
+    }
+}

pallets/torus0/rpc/src/lib.rs

@@ -394,33 +394,9 @@ pub mod pallet {
                 Error::<T>::NamespaceAlreadyExists
             );
 
-            let mut paths_to_create = namespace_path.parents();
-            paths_to_create.insert(0, namespace_path.clone());
-
-            let mut missing_paths = paths_to_create.as_slice();
-            for (i, segment) in paths_to_create.iter().skip(1).enumerate().rev() {
-                if !Namespaces::<T>::contains_key(&owner, segment) {
-                    missing_paths = paths_to_create
-                        .get(..i.saturating_add(1))
-                        .unwrap_or(&paths_to_create);
-                    break;
-                }
-            }
-
-            let current_count = NamespaceCount::<T>::get(&owner);
-
-            let pricing_config = NamespacePricingConfig::<T>::get();
-            let mut total_fee = BalanceOf::<T>::zero();
-            let mut total_deposit = BalanceOf::<T>::zero();
-
-            for (index, path) in missing_paths.iter().enumerate() {
-                let count = current_count.saturating_add(index as u32);
-                let fee = pricing_config.namespace_fee(count)?;
-                let deposit = pricing_config.namespace_deposit(path);
-
-                total_fee = total_fee.saturating_add(fee);
-                total_deposit = total_deposit.saturating_add(deposit);
-            }
+            let missing_paths = namespace::find_missing_paths::<T>(&owner, &namespace_path);
+            let (total_fee, total_deposit) =
+                namespace::calculate_cost::<T>(&owner, &missing_paths)?;
 
             T::Currency::reserve(&owner, total_deposit)?;
 
@@ -433,6 +409,7 @@ pub mod pallet {
             .map_err(|_| crate::Error::<T>::NotEnoughBalanceToRegisterAgent)?;
 
             let current_block = <frame_system::Pallet<T>>::block_number();
+            let pricing_config = crate::NamespacePricingConfig::<T>::get();
 
             for path in missing_paths.iter() {
                 let deposit = pricing_config.namespace_deposit(path);

pallets/torus0/src/lib.rs

@@ -3,7 +3,7 @@ use polkadot_sdk::{
     frame_support::{CloneNoBound, DebugNoBound, EqNoBound, PartialEqNoBound},
     frame_system::pallet_prelude::BlockNumberFor,
     sp_runtime::{
-        traits::{One, Saturating},
+        traits::{One, Saturating, Zero},
         FixedPointNumber, FixedU128,
     },
 };
@@ -112,3 +112,42 @@ pub struct NamespaceMetadata<T: Config> {
     /// Storage deposit paid for this namespace
     pub deposit: BalanceOf<T>,
 }
+
+pub fn find_missing_paths<T: Config>(
+    owner: &T::AccountId,
+    path: &NamespacePath,
+) -> Vec<NamespacePath> {
+    let mut paths_to_create = path.parents();
+    paths_to_create.insert(0, path.clone());
+
+    for (i, segment) in paths_to_create.iter().enumerate().rev() {
+        if !Namespaces::<T>::contains_key(owner, segment) {
+            return paths_to_create.get(..=i).unwrap_or_default().to_vec();
+        }
+    }
+
+    Default::default()
+}
+
+/// Calculates the total cost for registering, (Fee, Deposit)
+pub fn calculate_cost<T: Config>(
+    owner: &T::AccountId,
+    missing_paths: &[NamespacePath],
+) -> Result<(BalanceOf<T>, BalanceOf<T>), DispatchError> {
+    let current_count = NamespaceCount::<T>::get(owner);
+
+    let pricing_config = crate::NamespacePricingConfig::<T>::get();
+    let mut total_fee = BalanceOf::<T>::zero();
+    let mut total_deposit = BalanceOf::<T>::zero();
+
+    for (index, path) in missing_paths.iter().enumerate() {
+        let count = current_count.saturating_add(index as u32);
+        let fee = pricing_config.namespace_fee(count)?;
+        let deposit = pricing_config.namespace_deposit(path);
+
+        total_fee = total_fee.saturating_add(fee);
+        total_deposit = total_deposit.saturating_add(deposit);
+    }
+
+    Ok((total_fee, total_deposit))
+}