cargo fmt and update clap

Cargo.toml

@@ -205,7 +205,7 @@ jsonrpsee = { version = "0.15.1", features = ["server"] }
 log = "0.4.17"
 serde = { version = "1.0.136", default-features = false }
 serde_json = { version = "1.0", features = ["arbitrary_precision"] }
-clap = { version = "3.1.6", features = ["derive"] }
+clap = { version = "4.0.9", features = ["derive"] }
 rustc-hex = "2.1.0"
 
 # Pin version to work around substrate logging issue.

node-rpc/src/lib.rs

@@ -33,9 +33,7 @@
 use std::sync::Arc;
 
 use jsonrpsee::RpcModule;
-use polymesh_primitives::{
-    AccountId, Block, BlockNumber, Hash, IdentityId, Index, Moment, Ticker,
-};
+use polymesh_primitives::{AccountId, Block, BlockNumber, Hash, IdentityId, Index, Moment, Ticker};
 use sc_client_api::AuxStore;
 use sc_consensus_babe::{BabeConfiguration, Epoch};
 use sc_consensus_epochs::SharedEpochChanges;
@@ -101,7 +99,7 @@ pub fn create_full<C, P, SC, B>(
 ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 where
     C: ProvideRuntimeApi<Block>
-		    + sc_client_api::BlockBackend<Block>
+        + sc_client_api::BlockBackend<Block>
         + HeaderBackend<Block>
         + AuxStore
         + HeaderMetadata<Block, Error = BlockChainError>
@@ -167,7 +165,11 @@ where
     } = grandpa;
 
     let chain_name = chain_spec.name().to_string();
-    let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed");
+    let genesis_hash = client
+        .block_hash(0)
+        .ok()
+        .flatten()
+        .expect("Genesis block exists; qed");
     let properties = chain_spec.properties();
     io.merge(ChainSpec::new(chain_name, genesis_hash, properties).into_rpc())?;
 
@@ -199,8 +201,13 @@ where
     )?;
 
     io.merge(
-        SyncState::new(chain_spec, client.clone(), shared_authority_set, shared_epoch_changes)?
-            .into_rpc(),
+        SyncState::new(
+            chain_spec,
+            client.clone(),
+            shared_authority_set,
+            shared_epoch_changes,
+        )?
+        .into_rpc(),
     )?;
 
     io.merge(StateMigration::new(client.clone(), backend, deny_unsafe).into_rpc())?;
@@ -209,14 +216,10 @@ where
     io.merge(Staking::new(client.clone()).into_rpc())?;
     io.merge(Pips::new(client.clone()).into_rpc())?;
     io.merge(Identity::new(client.clone()).into_rpc())?;
-    io.merge(ProtocolFee::new(
-        client.clone(),
-    ).into_rpc())?;
+    io.merge(ProtocolFee::new(client.clone()).into_rpc())?;
     io.merge(Asset::new(client.clone()).into_rpc())?;
     io.merge(Group::from(client.clone()).into_rpc())?;
-    io.merge(ComplianceManager::new(
-        client,
-    ).into_rpc())?;
+    io.merge(ComplianceManager::new(client).into_rpc())?;
 
     Ok(io)
 }

pallets/group/rpc/src/lib.rs

@@ -5,12 +5,12 @@ use serde::{Deserialize, Serialize};
 
 use std::{marker::PhantomData, sync::Arc};
 
-use node_rpc::Error;
 use jsonrpsee::{
     core::RpcResult,
     proc_macros::rpc,
     types::error::{CallError, ErrorObject},
 };
+use node_rpc::Error;
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_runtime::{generic::BlockId, traits::Block as BlockT};

pallets/protocol-fee/rpc/src/lib.rs

@@ -13,12 +13,12 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 
-use node_rpc::Error;
 use jsonrpsee::{
     core::RpcResult,
     proc_macros::rpc,
     types::error::{CallError, ErrorObject},
 };
+use node_rpc::Error;
 pub use pallet_protocol_fee_rpc_runtime_api::{CappedFee, ProtocolFeeApi as ProtocolFeeRuntimeApi};
 use polymesh_common_utilities::protocol_fee::ProtocolOp;
 use sp_api::ProvideRuntimeApi;

pallets/staking/rpc/src/lib.rs

@@ -1,9 +1,9 @@
-use node_rpc::Error;
 use jsonrpsee::{
     core::RpcResult,
     proc_macros::rpc,
     types::error::{CallError, ErrorObject},
 };
+use node_rpc::Error;
 pub use pallet_staking_rpc_runtime_api::StakingApi as StakingRuntimeApi;
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;

src/command.rs

@@ -197,12 +197,10 @@ pub fn run() -> Result<()> {
                         cmd.run::<Block, service::GeneralExecutor>(config)
                     }
                     (BenchmarkCmd::Block(cmd), Network::Other) => {
-                        let FullServiceComponents { client, .. } = new_partial::<
-                            polymesh_runtime_develop::RuntimeApi,
-                            GeneralExecutor,
-                        >(
-                            &mut config
-                        )?;
+                        let FullServiceComponents { client, .. } =
+                            new_partial::<polymesh_runtime_develop::RuntimeApi, GeneralExecutor>(
+                                &mut config,
+                            )?;
                         cmd.run(client)
                     }
                     #[cfg(not(feature = "runtime-benchmarks"))]

src/service.rs

@@ -25,8 +25,8 @@ use sc_network_common::{protocol::event::Event, service::NetworkEventStream};
 use sc_service::{config::Configuration, error::Error as ServiceError, RpcHandlers, TaskManager};
 pub use sc_service::{
     config::{PrometheusConfig, Role},
-    ChainSpec, Error, PruningMode, RuntimeGenesis, TFullBackend, TFullCallExecutor,
-    TFullClient, TransactionPoolOptions,
+    ChainSpec, Error, PruningMode, RuntimeGenesis, TFullBackend, TFullCallExecutor, TFullClient,
+    TransactionPoolOptions,
 };
 use sc_telemetry::{Telemetry, TelemetryWorker};
 pub use sp_api::{ConstructRuntimeApi, Core as CoreApi, ProvideRuntimeApi, StateBackend};
@@ -180,7 +180,10 @@ pub fn new_partial<R, D>(
     FullServiceComponents<
         R,
         D,
-        impl Fn(sc_rpc::DenyUnsafe, sc_rpc::SubscriptionTaskExecutor) -> Result<jsonrpsee::RpcModule<()>, Error>,
+        impl Fn(
+            sc_rpc::DenyUnsafe,
+            sc_rpc::SubscriptionTaskExecutor,
+        ) -> Result<jsonrpsee::RpcModule<()>, Error>,
     >,
     Error,
 >
@@ -243,7 +246,7 @@ where
     let justification_import = grandpa_block_import.clone();
 
     let (block_import, babe_link) = sc_consensus_babe::block_import(
-		    sc_consensus_babe::configuration(&*client)?,
+        sc_consensus_babe::configuration(&*client)?,
         grandpa_block_import,
         client.clone(),
     )?;
@@ -298,7 +301,7 @@ where
         let keystore = keystore_container.sync_keystore();
         let chain_spec = config.chain_spec.cloned_box();
 
-		    let rpc_backend = backend.clone();
+        let rpc_backend = backend.clone();
         let rpc_extensions_builder = move |deny_unsafe, subscription_executor| {
             let deps = node_rpc::FullDeps {
                 client: client.clone(),
@@ -344,16 +347,16 @@ where
     R::RuntimeApi: RuntimeApiCollection<StateBackend = FullStateBackend>,
     D: NativeExecutionDispatch + 'static,
 {
-	  /// The task manager of the node.
+    /// The task manager of the node.
     pub task_manager: TaskManager,
-	  /// The client instance of the node.
+    /// The client instance of the node.
     pub client: Arc<FullClient<R, D>>,
-	  /// The networking service of the node.
+    /// The networking service of the node.
     pub network: Arc<NetworkService<Block, <Block as BlockT>::Hash>>,
-	  /// The transaction pool of the node.
+    /// The transaction pool of the node.
     pub transaction_pool: Arc<FullPool<R, D>>,
-	  /// The rpc handlers of the node.
-	  pub rpc_handlers: RpcHandlers,
+    /// The rpc handlers of the node.
+    pub rpc_handlers: RpcHandlers,
 }
 
 /// Creates a full service from the configuration.
@@ -610,19 +613,19 @@ type TaskResult = Result<TaskManager, ServiceError>;
 /// Create a new Testnet service for a full node.
 pub fn testnet_new_full(config: Configuration) -> TaskResult {
     new_full_base::<polymesh_runtime_testnet::RuntimeApi, TestnetExecutor, _>(config, |_, _| ())
-		    .map(|data| data.task_manager)
+        .map(|data| data.task_manager)
 }
 
 /// Create a new General node service for a full node.
 pub fn general_new_full(config: Configuration) -> TaskResult {
     new_full_base::<polymesh_runtime_develop::RuntimeApi, GeneralExecutor, _>(config, |_, _| ())
-		    .map(|data| data.task_manager)
+        .map(|data| data.task_manager)
 }
 
 /// Create a new Mainnet service for a full node.
 pub fn mainnet_new_full(config: Configuration) -> TaskResult {
     new_full_base::<polymesh_runtime_mainnet::RuntimeApi, MainnetExecutor, _>(config, |_, _| ())
-		    .map(|data| data.task_manager)
+        .map(|data| data.task_manager)
 }
 
 pub type NewChainOps<R, D> = (