diff --git a/node/src/benchmarking.rs b/node/src/benchmarking.rs
index eb83bdbe0..dbc3168ef 100644
--- a/node/src/benchmarking.rs
+++ b/node/src/benchmarking.rs
@@ -64,7 +64,11 @@ pub struct TransferKeepAliveBuilder {
 impl TransferKeepAliveBuilder {
     // Creates a new [`Self`] from the given client.
     pub fn new(client: Arc<FullClient>, dest: AccountId, value: Balance) -> Self {
-        Self { client, dest, value }
+        Self {
+            client,
+            dest,
+            value,
+        }
     }
 }
 
@@ -82,8 +86,11 @@ impl frame_benchmarking_cli::ExtrinsicBuilder for TransferKeepAliveBuilder {
         let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
             self.client.as_ref(),
             acc,
-            BalancesCall::transfer_keep_alive { dest: self.dest.clone().into(), value: self.value }
-                .into(),
+            BalancesCall::transfer_keep_alive {
+                dest: self.dest.clone().into(),
+                value: self.value,
+            }
+            .into(),
             nonce,
         )
         .into();
diff --git a/node/src/chain_spec.rs b/node/src/chain_spec.rs
index 0532c25c5..780364bf9 100644
--- a/node/src/chain_spec.rs
+++ b/node/src/chain_spec.rs
@@ -74,8 +74,17 @@ pub fn generate_config(network: String) -> Result<ChainSpec, String> {
     let block: u32 = state.block;
     // (name, tempo, immunity_period, min_allowed_weights, max_allowed_weights, max_allowed_uids,
     // founder)
-    let mut subnets: Vec<(Vec<u8>, u16, u16, u16, u16, u16, u16, u64, sp_runtime::AccountId32)> =
-        Vec::new();
+    let mut subnets: Vec<(
+        Vec<u8>,
+        u16,
+        u16,
+        u16,
+        u16,
+        u16,
+        u16,
+        u64,
+        sp_runtime::AccountId32,
+    )> = Vec::new();
     let mut modules: Vec<Vec<(sp_runtime::AccountId32, Vec<u8>, Vec<u8>, Vec<(u16, u16)>)>> =
         Vec::new();
     let mut stake_to: Vec<Vec<(sp_runtime::AccountId32, Vec<(sp_runtime::AccountId32, u64)>)>> =
diff --git a/node/src/command.rs b/node/src/command.rs
index 39d28f828..a1d7d51da 100644
--- a/node/src/command.rs
+++ b/node/src/command.rs
@@ -40,8 +40,9 @@ impl SubstrateCli for Cli {
             "test" => Box::new(chain_spec::testnet_config()?),
             "main" => Box::new(chain_spec::mainnet_config()?),
             "dev" => Box::new(chain_spec::mainnet_config()?),
-            path =>
-                Box::new(chain_spec::ChainSpec::from_json_file(std::path::PathBuf::from(path))?),
+            path => Box::new(chain_spec::ChainSpec::from_json_file(
+                std::path::PathBuf::from(path),
+            )?),
         })
     }
 }
@@ -55,53 +56,73 @@ pub fn run() -> sc_cli::Result<()> {
         Some(Subcommand::BuildSpec(cmd)) => {
             let runner = cli.create_runner(cmd)?;
             runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
-        },
+        }
         Some(Subcommand::CheckBlock(cmd)) => {
             let runner = cli.create_runner(cmd)?;
             runner.async_run(|config| {
-                let PartialComponents { client, task_manager, import_queue, .. } =
-                    service::new_partial(&config)?;
+                let PartialComponents {
+                    client,
+                    task_manager,
+                    import_queue,
+                    ..
+                } = service::new_partial(&config)?;
                 Ok((cmd.run(client, import_queue), task_manager))
             })
-        },
+        }
         Some(Subcommand::ExportBlocks(cmd)) => {
             let runner = cli.create_runner(cmd)?;
             runner.async_run(|config| {
-                let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?;
+                let PartialComponents {
+                    client,
+                    task_manager,
+                    ..
+                } = service::new_partial(&config)?;
                 Ok((cmd.run(client, config.database), task_manager))
             })
-        },
+        }
         Some(Subcommand::ExportState(cmd)) => {
             let runner = cli.create_runner(cmd)?;
             runner.async_run(|config| {
-                let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?;
+                let PartialComponents {
+                    client,
+                    task_manager,
+                    ..
+                } = service::new_partial(&config)?;
                 Ok((cmd.run(client, config.chain_spec), task_manager))
             })
-        },
+        }
         Some(Subcommand::ImportBlocks(cmd)) => {
             let runner = cli.create_runner(cmd)?;
             runner.async_run(|config| {
-                let PartialComponents { client, task_manager, import_queue, .. } =
-                    service::new_partial(&config)?;
+                let PartialComponents {
+                    client,
+                    task_manager,
+                    import_queue,
+                    ..
+                } = service::new_partial(&config)?;
                 Ok((cmd.run(client, import_queue), task_manager))
             })
-        },
+        }
         Some(Subcommand::PurgeChain(cmd)) => {
             let runner = cli.create_runner(cmd)?;
             runner.sync_run(|config| cmd.run(config.database))
-        },
+        }
         Some(Subcommand::Revert(cmd)) => {
             let runner = cli.create_runner(cmd)?;
             runner.async_run(|config| {
-                let PartialComponents { client, task_manager, backend, .. } =
-                    service::new_partial(&config)?;
+                let PartialComponents {
+                    client,
+                    task_manager,
+                    backend,
+                    ..
+                } = service::new_partial(&config)?;
                 let aux_revert = Box::new(|client, _, blocks| {
                     sc_consensus_grandpa::revert(client, blocks)?;
                     Ok(())
                 });
                 Ok((cmd.run(client, backend, Some(aux_revert)), task_manager))
             })
-        },
+        }
         Some(Subcommand::Benchmark(cmd)) => {
             let runner = cli.create_runner(cmd)?;
 
@@ -117,15 +138,15 @@ pub fn run() -> sc_cli::Result<()> {
                                 "Runtime benchmarking wasn't enabled when building the node. \
 							You can enable it with `--features runtime-benchmarks`."
                                     .into(),
-                            )
+                            );
                         }
 
                         cmd.run::<Block, SubstrateHostFunctions>(config)
-                    },
+                    }
                     BenchmarkCmd::Block(cmd) => {
                         let PartialComponents { client, .. } = service::new_partial(&config)?;
                         cmd.run(client)
-                    },
+                    }
                     #[cfg(not(feature = "runtime-benchmarks"))]
                     BenchmarkCmd::Storage(_) => Err(
                         "Storage benchmarking can be enabled with `--features runtime-benchmarks`."
@@ -133,13 +154,14 @@ pub fn run() -> sc_cli::Result<()> {
                     ),
                     #[cfg(feature = "runtime-benchmarks")]
                     BenchmarkCmd::Storage(cmd) => {
-                        let PartialComponents { client, backend, .. } =
-                            service::new_partial(&config)?;
+                        let PartialComponents {
+                            client, backend, ..
+                        } = service::new_partial(&config)?;
                         let db = backend.expose_db();
                         let storage = backend.expose_storage();
 
                         cmd.run(config, client, db, storage)
-                    },
+                    }
                     BenchmarkCmd::Overhead(cmd) => {
                         let PartialComponents { client, .. } = service::new_partial(&config)?;
                         let ext_builder = RemarkBuilder::new(client.clone());
@@ -151,7 +173,7 @@ pub fn run() -> sc_cli::Result<()> {
                             Vec::new(),
                             &ext_builder,
                         )
-                    },
+                    }
                     BenchmarkCmd::Extrinsic(cmd) => {
                         let PartialComponents { client, .. } = service::new_partial(&config)?;
                         // Register the *Remark* and *TKA* builders.
@@ -165,12 +187,13 @@ pub fn run() -> sc_cli::Result<()> {
                         ]);
 
                         cmd.run(client, inherent_benchmark_data()?, Vec::new(), &ext_factory)
-                    },
-                    BenchmarkCmd::Machine(cmd) =>
-                        cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone()),
+                    }
+                    BenchmarkCmd::Machine(cmd) => {
+                        cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone())
+                    }
                 }
             })
-        },
+        }
         #[cfg(feature = "try-runtime")]
         Some(Subcommand::TryRuntime(cmd)) => {
             use crate::service::ExecutorDispatch;
@@ -191,7 +214,7 @@ pub fn run() -> sc_cli::Result<()> {
                     task_manager,
                 ))
             })
-        },
+        }
         #[cfg(not(feature = "try-runtime"))]
         Some(Subcommand::TryRuntime) => Err("TryRuntime wasn't enabled when building the node. \
 				You can enable it with `--features try-runtime`."
@@ -199,12 +222,12 @@ pub fn run() -> sc_cli::Result<()> {
         Some(Subcommand::ChainInfo(cmd)) => {
             let runner = cli.create_runner(cmd)?;
             runner.sync_run(|config| cmd.run::<Block>(&config))
-        },
+        }
         None => {
             let runner = cli.create_runner(&cli.run)?;
             runner.run_node_until_exit(|config| async move {
                 service::new_full(config).map_err(sc_cli::Error::Service)
             })
-        },
+        }
     }
 }
diff --git a/node/src/rpc.rs b/node/src/rpc.rs
index a6fa15208..82714cba7 100644
--- a/node/src/rpc.rs
+++ b/node/src/rpc.rs
@@ -45,7 +45,11 @@ where
     use substrate_frame_rpc_system::{System, SystemApiServer};
 
     let mut module = RpcModule::new(());
-    let FullDeps { client, pool, deny_unsafe } = deps;
+    let FullDeps {
+        client,
+        pool,
+        deny_unsafe,
+    } = deps;
 
     module.merge(System::new(client.clone(), pool, deny_unsafe).into_rpc())?;
     module.merge(TransactionPayment::new(client.clone()).into_rpc())?;
diff --git a/node/src/service.rs b/node/src/service.rs
index a12456e6b..64e71afb0 100644
--- a/node/src/service.rs
+++ b/node/src/service.rs
@@ -213,8 +213,11 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
         let pool = transaction_pool.clone();
 
         Box::new(move |deny_unsafe, _| {
-            let deps =
-                crate::rpc::FullDeps { client: client.clone(), pool: pool.clone(), deny_unsafe };
+            let deps = crate::rpc::FullDeps {
+                client: client.clone(),
+                pool: pool.clone(),
+                deny_unsafe,
+            };
             crate::rpc::create_full(deps).map_err(Into::into)
         })
     };
@@ -285,7 +288,11 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
     if enable_grandpa {
         // if the node isn't actively participating in consensus then it doesn't
         // need a keystore, regardless of which protocol we use below.
-        let keystore = if role.is_authority() { Some(keystore_container.keystore()) } else { None };
+        let keystore = if role.is_authority() {
+            Some(keystore_container.keystore())
+        } else {
+            None
+        };
 
         let grandpa_config = sc_consensus_grandpa::Config {
             // FIXME #1578 make this available through chainspec
diff --git a/pallets/subspace/rpc/src/lib.rs b/pallets/subspace/rpc/src/lib.rs
index ab9701de3..6113cafa4 100644
--- a/pallets/subspace/rpc/src/lib.rs
+++ b/pallets/subspace/rpc/src/lib.rs
@@ -43,7 +43,10 @@ pub struct SubspacePallet<C, Block> {
 
 impl<C, Block> SubspacePallet<C, Block> {
     pub fn new(client: Arc<C>) -> Self {
-        Self { client, _marker: Default::default() }
+        Self {
+            client,
+            _marker: Default::default(),
+        }
     }
 }
 
@@ -58,7 +61,10 @@ where
         let at = at.unwrap_or_else(|| self.client.info().best_hash);
 
         let value = api.get_burn_rate(at).map_err(runtime_error_into_rpc_err);
-        Ok(Custom { code: 200, burn_rate: value.unwrap() })
+        Ok(Custom {
+            code: 200,
+            burn_rate: value.unwrap(),
+        })
     }
 
     fn get_module_info(
diff --git a/pallets/subspace/src/benchmarking.rs b/pallets/subspace/src/benchmarking.rs
index 3ad6b91d3..fd498cd6f 100644
--- a/pallets/subspace/src/benchmarking.rs
+++ b/pallets/subspace/src/benchmarking.rs
@@ -18,8 +18,12 @@ fn default_register_helper<T: Config>() -> (Vec<u8>, Vec<u8>, Vec<u8>, T::Accoun
     let address: Vec<u8> = b"address".to_vec();
     let module_key: T::AccountId = account("key", 0, SEED);
 
-    let netuid =
-        register_helper::<T>(network.clone(), name.clone(), address.clone(), module_key.clone());
+    let netuid = register_helper::<T>(
+        network.clone(),
+        name.clone(),
+        address.clone(),
+        module_key.clone(),
+    );
 
     (network, name, address, module_key, netuid)
 }
@@ -120,7 +124,10 @@ mod benchmarks {
 
         let netuid = <Pallet<T>>::get_netuid_for_name(network).unwrap_or(u16::MAX);
 
-        assert!(<Pallet<T>>::is_registered(netuid, &module_key), "Register failed");
+        assert!(
+            <Pallet<T>>::is_registered(netuid, &module_key),
+            "Register failed"
+        );
 
         Ok(())
     }
@@ -160,7 +167,12 @@ mod benchmarks {
         let (network, name, address, module_key, netuid) = default_register_helper::<T>();
 
         #[extrinsic_call]
-        add_stake(RawOrigin::Signed(module_key.clone()), netuid, module_key.clone(), MIN_STAKE);
+        add_stake(
+            RawOrigin::Signed(module_key.clone()),
+            netuid,
+            module_key.clone(),
+            MIN_STAKE,
+        );
 
         Ok(())
     }
@@ -254,7 +266,11 @@ mod benchmarks {
         }
 
         #[extrinsic_call]
-        transfer_multiple(RawOrigin::Signed(module_key.clone()), new_module_keys, amounts);
+        transfer_multiple(
+            RawOrigin::Signed(module_key.clone()),
+            new_module_keys,
+            amounts,
+        );
 
         Ok(())
     }
@@ -275,7 +291,12 @@ mod benchmarks {
         );
 
         #[extrinsic_call]
-        remove_stake(RawOrigin::Signed(module_key.clone()), netuid, module_key.clone(), MIN_STAKE);
+        remove_stake(
+            RawOrigin::Signed(module_key.clone()),
+            netuid,
+            module_key.clone(),
+            MIN_STAKE,
+        );
 
         Ok(())
     }
@@ -287,7 +308,12 @@ mod benchmarks {
         let (netuid, module_keys, amounts) = add_stake_multiple_helper::<T>(caller.clone());
 
         #[extrinsic_call]
-        remove_stake_multiple(RawOrigin::Signed(caller.clone()), netuid, module_keys, amounts);
+        remove_stake_multiple(
+            RawOrigin::Signed(caller.clone()),
+            netuid,
+            module_keys,
+            amounts,
+        );
 
         Ok(())
     }
diff --git a/pallets/subspace/src/global.rs b/pallets/subspace/src/global.rs
index 7833e30a0..922ae8c8f 100644
--- a/pallets/subspace/src/global.rs
+++ b/pallets/subspace/src/global.rs
@@ -32,20 +32,32 @@ impl<T: Config> Pallet<T> {
         // check if the name already exists
         ensure!(params.max_name_length > 0, Error::<T>::InvalidMaxNameLength);
 
-        ensure!(params.max_allowed_subnets > 0, Error::<T>::InvalidMaxAllowedSubnets);
+        ensure!(
+            params.max_allowed_subnets > 0,
+            Error::<T>::InvalidMaxAllowedSubnets
+        );
 
-        ensure!(params.max_allowed_modules > 0, Error::<T>::InvalidMaxAllowedModules);
+        ensure!(
+            params.max_allowed_modules > 0,
+            Error::<T>::InvalidMaxAllowedModules
+        );
 
         ensure!(
             params.max_registrations_per_block > 0,
             Error::<T>::InvalidMaxRegistrationsPerBlock
         );
 
-        ensure!(params.vote_threshold < 100, Error::<T>::InvalidVoteThreshold);
+        ensure!(
+            params.vote_threshold < 100,
+            Error::<T>::InvalidVoteThreshold
+        );
 
         ensure!(params.max_proposals > 0, Error::<T>::InvalidMaxProposals);
 
-        ensure!(params.unit_emission <= og_params.unit_emission, Error::<T>::InvalidUnitEmission);
+        ensure!(
+            params.unit_emission <= og_params.unit_emission,
+            Error::<T>::InvalidUnitEmission
+        );
 
         ensure!(params.tx_rate_limit > 0, Error::<T>::InvalidTxRateLimit);
 
@@ -136,7 +148,10 @@ impl<T: Config> Pallet<T> {
 
     pub fn do_update_global(origin: T::RuntimeOrigin, params: GlobalParams) -> DispatchResult {
         ensure_root(origin)?;
-        ensure!(Self::get_vote_mode_global() == AUTHORITY_MODE, Error::<T>::InvalidVoteMode);
+        ensure!(
+            Self::get_vote_mode_global() == AUTHORITY_MODE,
+            Error::<T>::InvalidVoteMode
+        );
         Self::set_global_params(params);
         Ok(())
     }
diff --git a/pallets/subspace/src/lib.rs b/pallets/subspace/src/lib.rs
index e4c8d6e8c..baae2a401 100644
--- a/pallets/subspace/src/lib.rs
+++ b/pallets/subspace/src/lib.rs
@@ -421,7 +421,11 @@ pub mod pallet {
 
     #[pallet::type_value]
     pub fn DefaultVoterInfo<T: Config>() -> VoterInfo {
-        VoterInfo { proposal_id: u64::MAX, votes: 0, participant_index: u16::MAX }
+        VoterInfo {
+            proposal_id: u64::MAX,
+            votes: 0,
+            participant_index: u16::MAX,
+        }
     }
     #[pallet::storage] // --- MAP ( netuid ) --> epoch
     pub type Voter2Info<T: Config> =
@@ -732,7 +736,7 @@ pub mod pallet {
         MaxAllowedSubnetsSet(u16), // --- Event created when setting the maximum allowed subnets
         MaxAllowedModulesSet(u16), // --- Event created when setting the maximum allowed modules
         MaxRegistrationsPerBlockSet(u16), /* --- Event created when we set max registrations
-                                           * per block */
+                              * per block */
         GlobalUpdate(u16, u16, u16, u16, u64, u64),
         GlobalProposalAccepted(u64),      // (id)
         CustomProposalAccepted(u64),      // (id)
@@ -1297,14 +1301,14 @@ pub mod pallet {
             if Uids::<T>::contains_key(netuid, &key) {
                 let uid: u16 = Self::get_uid_for_key(netuid, &key.clone());
                 let current_block_number: u64 = Self::get_current_block_as_u64();
-                return current_block_number - Self::get_last_update_for_uid(netuid, uid as u16)
+                return current_block_number - Self::get_last_update_for_uid(netuid, uid as u16);
             }
             0
         }
         // --- Returns the transaction priority for setting weights.
         pub fn get_priority_stake(key: &T::AccountId, netuid: u16) -> u64 {
             if Uids::<T>::contains_key(netuid, &key) {
-                return Self::get_stake(netuid, key)
+                return Self::get_stake(netuid, key);
             }
             0
         }
@@ -1410,8 +1414,12 @@ where
         match call.is_sub_type() {
             Some(Call::set_weights { netuid, .. }) => {
                 let priority: u64 = Self::get_priority_set_weights(who, *netuid);
-                Ok(ValidTransaction { priority, longevity: 1, ..Default::default() })
-            },
+                Ok(ValidTransaction {
+                    priority,
+                    longevity: 1,
+                    ..Default::default()
+                })
+            }
             Some(Call::add_stake { .. }) => Ok(ValidTransaction {
                 priority: Self::get_priority_vanilla(who),
                 ..Default::default()
@@ -1452,43 +1460,43 @@ where
             Some(Call::add_stake { .. }) => {
                 let transaction_fee = 0;
                 Ok((CallType::AddStake, transaction_fee, who.clone()))
-            },
+            }
             Some(Call::add_stake_multiple { .. }) => {
                 let transaction_fee = 0;
                 Ok((CallType::AddStakeMultiple, transaction_fee, who.clone()))
-            },
+            }
             Some(Call::remove_stake { .. }) => {
                 let transaction_fee = 0;
                 Ok((CallType::RemoveStake, transaction_fee, who.clone()))
-            },
+            }
             Some(Call::remove_stake_multiple { .. }) => {
                 let transaction_fee = 0;
                 Ok((CallType::RemoveStakeMultiple, transaction_fee, who.clone()))
-            },
+            }
             Some(Call::transfer_stake { .. }) => {
                 let transaction_fee = 0;
                 Ok((CallType::TransferStake, transaction_fee, who.clone()))
-            },
+            }
             Some(Call::transfer_multiple { .. }) => {
                 let transaction_fee = 0;
                 Ok((CallType::TransferMultiple, transaction_fee, who.clone()))
-            },
+            }
             Some(Call::set_weights { .. }) => {
                 let transaction_fee = 0;
                 Ok((CallType::SetWeights, transaction_fee, who.clone()))
-            },
+            }
             Some(Call::register { .. }) => {
                 let transaction_fee = 0;
                 Ok((CallType::Register, transaction_fee, who.clone()))
-            },
+            }
             Some(Call::update_module { .. }) => {
                 let transaction_fee = 0;
                 Ok((CallType::Serve, transaction_fee, who.clone()))
-            },
+            }
             _ => {
                 let transaction_fee = 0;
                 Ok((CallType::Other, transaction_fee, who.clone()))
-            },
+            }
         }
     }
 
@@ -1503,38 +1511,38 @@ where
             match call_type {
                 CallType::SetWeights => {
                     log::debug!("Not Implemented!");
-                },
+                }
                 CallType::AddStake => {
                     log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                },
+                }
 
                 CallType::AddStakeMultiple => {
                     log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                },
+                }
                 CallType::RemoveStake => {
                     log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                },
+                }
                 CallType::RemoveStakeMultiple => {
                     log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                },
+                }
                 CallType::TransferStake => {
                     log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                },
+                }
                 CallType::TransferStakeMultiple => {
                     log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                },
+                }
                 CallType::TransferMultiple => {
                     log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                },
+                }
                 CallType::AddNetwork => {
                     log::debug!("Not Implemented! Need to add potential transaction fees here.");
-                },
+                }
                 CallType::Register => {
                     log::debug!("Not Implemented!");
-                },
+                }
                 _ => {
                     log::debug!("Not Implemented!");
-                },
+                }
             }
         }
         Ok(())
diff --git a/pallets/subspace/src/math.rs b/pallets/subspace/src/math.rs
index f1ad165a8..c7c7480f4 100644
--- a/pallets/subspace/src/math.rs
+++ b/pallets/subspace/src/math.rs
@@ -115,13 +115,14 @@ pub fn exp_safe(input: I32F32) -> I32F32 {
     match exp(safe_input) {
         Ok(val) => {
             output = val;
-        },
-        Err(_err) =>
+        }
+        Err(_err) => {
             if safe_input <= 0 {
                 output = I32F32::from_num(0);
             } else {
                 output = I32F32::max_value();
-            },
+            }
+        }
     }
     output
 }
@@ -146,7 +147,7 @@ pub fn is_topk(vector: &Vec<I32F32>, k: usize) -> Vec<bool> {
     let n: usize = vector.len();
     let mut result: Vec<bool> = vec![true; n];
     if n < k {
-        return result
+        return result;
     }
     let mut idxs: Vec<usize> = (0..n).collect();
     idxs.sort_by_key(|&idx| &vector[idx]); // ascending stable sort
@@ -161,7 +162,7 @@ pub fn is_topk(vector: &Vec<I32F32>, k: usize) -> Vec<bool> {
 pub fn normalize(x: &Vec<I32F32>) -> Vec<I32F32> {
     let x_sum: I32F32 = sum(x);
     if x_sum != I32F32::from_num(0.0 as f32) {
-        return x.iter().map(|xi| xi / x_sum).collect()
+        return x.iter().map(|xi| xi / x_sum).collect();
     } else {
         x.clone()
     }
@@ -172,7 +173,7 @@ pub fn normalize(x: &Vec<I32F32>) -> Vec<I32F32> {
 pub fn inplace_normalize(x: &mut Vec<I32F32>) {
     let x_sum: I32F32 = x.iter().sum();
     if x_sum == I32F32::from_num(0.0) {
-        return
+        return;
     }
     for i in 0..x.len() {
         x[i] = x[i] / x_sum;
@@ -184,7 +185,7 @@ pub fn inplace_normalize(x: &mut Vec<I32F32>) {
 pub fn inplace_normalize_64(x: &mut Vec<I64F64>) {
     let x_sum: I64F64 = x.iter().sum();
     if x_sum == I64F64::from_num(0) {
-        return
+        return;
     }
     for i in 0..x.len() {
         x[i] = x[i] / x_sum;
@@ -231,10 +232,10 @@ pub fn inplace_row_normalize_sparse(sparse_matrix: &mut Vec<Vec<(u16, I32F32)>>)
 #[allow(dead_code)]
 pub fn row_sum(x: &Vec<Vec<I32F32>>) -> Vec<I32F32> {
     if x.len() == 0 {
-        return vec![]
+        return vec![];
     }
     if x[0].len() == 0 {
-        return vec![]
+        return vec![];
     }
     let rows = x.len();
     let mut result: Vec<I32F32> = vec![I32F32::from_num(0); rows];
@@ -263,10 +264,10 @@ pub fn row_sum_sparse(sparse_matrix: &Vec<Vec<(u16, I32F32)>>) -> Vec<I32F32> {
 #[allow(dead_code)]
 pub fn col_sum(x: &Vec<Vec<I32F32>>) -> Vec<I32F32> {
     if x.len() == 0 {
-        return vec![]
+        return vec![];
     }
     if x[0].len() == 0 {
-        return vec![]
+        return vec![];
     }
     let cols = x[0].len();
     let mut result: Vec<I32F32> = vec![I32F32::from_num(0); cols];
@@ -303,7 +304,7 @@ pub fn inplace_col_normalize_sparse(sparse_matrix: &mut Vec<Vec<(u16, I32F32)>>,
     for sparse_row in sparse_matrix.iter_mut() {
         for (j, value) in sparse_row.iter_mut() {
             if col_sum[*j as usize] == I32F32::from_num(0.0 as f32) {
-                continue
+                continue;
             }
             *value /= col_sum[*j as usize];
         }
@@ -314,10 +315,10 @@ pub fn inplace_col_normalize_sparse(sparse_matrix: &mut Vec<Vec<(u16, I32F32)>>,
 #[allow(dead_code)]
 pub fn inplace_col_normalize(x: &mut Vec<Vec<I32F32>>) {
     if x.len() == 0 {
-        return
+        return;
     }
     if x[0].len() == 0 {
-        return
+        return;
     }
     let cols = x[0].len();
     let mut col_sum: Vec<I32F32> = vec![I32F32::from_num(0.0); cols];
@@ -329,7 +330,7 @@ pub fn inplace_col_normalize(x: &mut Vec<Vec<I32F32>>) {
     }
     for j in 0..cols {
         if col_sum[j] == I32F32::from_num(0.0 as f32) {
-            continue
+            continue;
         }
         for i in 0..x.len() {
             x[i][j] /= col_sum[j];
@@ -341,7 +342,7 @@ pub fn inplace_col_normalize(x: &mut Vec<Vec<I32F32>>) {
 #[allow(dead_code)]
 pub fn inplace_mask_vector(mask: &Vec<bool>, vector: &mut Vec<I32F32>) {
     if mask.len() == 0 {
-        return
+        return;
     }
     assert_eq!(mask.len(), vector.len());
     let zero: I32F32 = I32F32::from_num(0.0);
@@ -356,10 +357,10 @@ pub fn inplace_mask_vector(mask: &Vec<bool>, vector: &mut Vec<I32F32>) {
 #[allow(dead_code)]
 pub fn inplace_mask_matrix(mask: &Vec<Vec<bool>>, matrix: &mut Vec<Vec<I32F32>>) {
     if mask.len() == 0 {
-        return
+        return;
     }
     if mask[0].len() == 0 {
-        return
+        return;
     }
     assert_eq!(mask.len(), matrix.len());
     let zero: I32F32 = I32F32::from_num(0.0);
@@ -377,7 +378,7 @@ pub fn inplace_mask_matrix(mask: &Vec<Vec<bool>>, matrix: &mut Vec<Vec<I32F32>>)
 pub fn inplace_mask_rows(mask: &Vec<bool>, matrix: &mut Vec<Vec<I32F32>>) {
     let rows = matrix.len();
     if rows == 0 {
-        return
+        return;
     }
     let cols = matrix[0].len();
     assert_eq!(mask.len(), rows);
@@ -393,10 +394,10 @@ pub fn inplace_mask_rows(mask: &Vec<bool>, matrix: &mut Vec<Vec<I32F32>>) {
 #[allow(dead_code)]
 pub fn inplace_mask_diag(matrix: &mut Vec<Vec<I32F32>>) {
     if matrix.len() == 0 {
-        return
+        return;
     }
     if matrix[0].len() == 0 {
-        return
+        return;
     }
     assert_eq!(matrix.len(), matrix[0].len());
     let zero: I32F32 = I32F32::from_num(0.0);
@@ -461,10 +462,10 @@ pub fn vec_mask_sparse_matrix(
 #[allow(dead_code)]
 pub fn row_hadamard(matrix: &Vec<Vec<I32F32>>, vector: &Vec<I32F32>) -> Vec<Vec<I32F32>> {
     if matrix.len() == 0 {
-        return vec![vec![]]
+        return vec![vec![]];
     }
     if matrix[0].len() == 0 {
-        return vec![vec![]]
+        return vec![vec![]];
     }
     let mut result: Vec<Vec<I32F32>> =
         vec![vec![I32F32::from_num(0.0); matrix[0].len()]; matrix.len()];
@@ -495,10 +496,10 @@ pub fn row_hadamard_sparse(
 #[allow(dead_code)]
 pub fn matmul(matrix: &Vec<Vec<I32F32>>, vector: &Vec<I32F32>) -> Vec<I32F32> {
     if matrix.len() == 0 {
-        return vec![]
+        return vec![];
     }
     if matrix[0].len() == 0 {
-        return vec![]
+        return vec![];
     }
     assert!(matrix.len() == vector.len());
     let mut result: Vec<I32F32> = vec![I32F32::from_num(0.0); matrix[0].len()];
@@ -516,10 +517,10 @@ pub fn matmul(matrix: &Vec<Vec<I32F32>>, vector: &Vec<I32F32>) -> Vec<I32F32> {
 #[allow(dead_code)]
 pub fn matmul_transpose(matrix: &Vec<Vec<I32F32>>, vector: &Vec<I32F32>) -> Vec<I32F32> {
     if matrix.len() == 0 {
-        return vec![]
+        return vec![];
     }
     if matrix[0].len() == 0 {
-        return vec![]
+        return vec![];
     }
     assert!(matrix[0].len() == vector.len());
     let mut result: Vec<I32F32> = vec![I32F32::from_num(0.0); matrix.len()];
@@ -613,7 +614,7 @@ pub fn clip(
 ) -> Vec<Vec<I32F32>> {
     // Check Nill length.
     if x.len() == 0 {
-        return vec![vec![]]
+        return vec![vec![]];
     }
     let mut result: Vec<Vec<I32F32>> = vec![vec![lower; x[0].len()]; x.len()];
     for i in 0..x.len() {
@@ -702,10 +703,10 @@ pub fn weighted_median(
 ) -> I32F32 {
     let n = partition_idx.len();
     if n == 0 {
-        return I32F32::from_num(0)
+        return I32F32::from_num(0);
     }
     if n == 1 {
-        return score[partition_idx[0]]
+        return score[partition_idx[0]];
     }
     assert!(stake.len() == score.len());
     let mid_idx: usize = n / 2;
@@ -716,7 +717,7 @@ pub fn weighted_median(
     let mut upper: Vec<usize> = vec![];
     for &idx in partition_idx.iter() {
         if score[idx] == pivot {
-            continue
+            continue;
         }
         if score[idx] < pivot {
             lo_stake += stake[idx];
@@ -727,7 +728,7 @@ pub fn weighted_median(
         }
     }
     if (partition_lo + lo_stake <= minority) && (minority < partition_hi - hi_stake) {
-        return pivot
+        return pivot;
     } else if (minority < partition_lo + lo_stake) && (lower.len() > 0) {
         return weighted_median(
             stake,
@@ -736,7 +737,7 @@ pub fn weighted_median(
             minority,
             partition_lo,
             partition_lo + lo_stake,
-        )
+        );
     } else if (partition_hi - hi_stake <= minority) && (upper.len() > 0) {
         return weighted_median(
             stake,
@@ -745,7 +746,7 @@ pub fn weighted_median(
             minority,
             partition_hi - hi_stake,
             partition_hi,
-        )
+        );
     }
     pivot
 }
@@ -810,7 +811,7 @@ pub fn weighted_median_col_sparse(
     let mut k: usize = 0;
     for r in 0..rows {
         if stake[r] <= zero {
-            continue
+            continue;
         }
         for (c, val) in score[r].iter() {
             use_score[*c as usize][k] = *val;
@@ -818,8 +819,14 @@ pub fn weighted_median_col_sparse(
         k += 1;
     }
     for c in 0..columns as usize {
-        median[c] =
-            weighted_median(&use_stake, &use_score[c], &stake_idx, minority, zero, stake_sum);
+        median[c] = weighted_median(
+            &use_stake,
+            &use_score[c],
+            &stake_idx,
+            minority,
+            zero,
+            stake_sum,
+        );
     }
     median
 }
@@ -829,10 +836,10 @@ pub fn weighted_median_col_sparse(
 pub fn hadamard(mat1: &Vec<Vec<I32F32>>, mat2: &Vec<Vec<I32F32>>) -> Vec<Vec<I32F32>> {
     assert!(mat1.len() == mat2.len());
     if mat1.len() == 0 {
-        return vec![vec![]; 1]
+        return vec![vec![]; 1];
     }
     if mat1[0].len() == 0 {
-        return vec![vec![]; 1]
+        return vec![vec![]; 1];
     }
     let mut result: Vec<Vec<I32F32>> = vec![vec![I32F32::from_num(0); mat1[0].len()]; mat1.len()];
     for i in 0..mat1.len() {
@@ -880,10 +887,10 @@ pub fn hadamard_sparse(
 #[allow(dead_code)]
 pub fn mat_ema(new: &Vec<Vec<I32F32>>, old: &Vec<Vec<I32F32>>, alpha: I32F32) -> Vec<Vec<I32F32>> {
     if new.len() == 0 {
-        return vec![vec![]; 1]
+        return vec![vec![]; 1];
     }
     if new[0].len() == 0 {
-        return vec![vec![]; 1]
+        return vec![vec![]; 1];
     }
     let one_minus_alpha: I32F32 = I32F32::from_num(1.0) - alpha;
     let mut result: Vec<Vec<I32F32>> = vec![vec![I32F32::from_num(0.0); new[0].len()]; new.len()];
@@ -1116,8 +1123,16 @@ mod tests {
     fn test_math_vec_to_mat_fixed() {
         let vector: Vec<f32> = vec![0., 1., 2., 0., 10., 100.];
         let target: Vec<Vec<I32F32>> = vec![
-            vec![I32F32::from_num(0.), I32F32::from_num(1.), I32F32::from_num(2.)],
-            vec![I32F32::from_num(0.), I32F32::from_num(10.), I32F32::from_num(100.)],
+            vec![
+                I32F32::from_num(0.),
+                I32F32::from_num(1.),
+                I32F32::from_num(2.),
+            ],
+            vec![
+                I32F32::from_num(0.),
+                I32F32::from_num(10.),
+                I32F32::from_num(100.),
+            ],
         ];
         let mat = vec_to_mat_fixed(&vector, 2, false);
         assert_mat_compare(&mat, &target, I32F32::from_num(0));
@@ -1164,8 +1179,14 @@ mod tests {
     fn test_math_vec_to_sparse_mat_fixed() {
         let vector: Vec<f32> = vec![0., 1., 2., 0., 10., 100.];
         let target: Vec<Vec<(u16, I32F32)>> = vec![
-            vec![(1 as u16, I32F32::from_num(1.)), (2 as u16, I32F32::from_num(2.))],
-            vec![(1 as u16, I32F32::from_num(10.)), (2 as u16, I32F32::from_num(100.))],
+            vec![
+                (1 as u16, I32F32::from_num(1.)),
+                (2 as u16, I32F32::from_num(2.)),
+            ],
+            vec![
+                (1 as u16, I32F32::from_num(10.)),
+                (2 as u16, I32F32::from_num(100.)),
+            ],
         ];
         let mat = vec_to_sparse_mat_fixed(&vector, 2, false);
         assert_sparse_mat_compare(&mat, &target, I32F32::from_num(0));
@@ -1176,8 +1197,14 @@ mod tests {
         let vector: Vec<f32> = vec![0., 1., 2., 0., 10., 100.];
         let target: Vec<Vec<(u16, I32F32)>> = vec![
             vec![],
-            vec![(0 as u16, I32F32::from_num(1.)), (1 as u16, I32F32::from_num(10.))],
-            vec![(0 as u16, I32F32::from_num(2.)), (1 as u16, I32F32::from_num(100.))],
+            vec![
+                (0 as u16, I32F32::from_num(1.)),
+                (1 as u16, I32F32::from_num(10.)),
+            ],
+            vec![
+                (0 as u16, I32F32::from_num(2.)),
+                (1 as u16, I32F32::from_num(100.)),
+            ],
         ];
         let mat = vec_to_sparse_mat_fixed(&vector, 2, true);
         assert_sparse_mat_compare(&mat, &target, I32F32::from_num(0));
@@ -1292,12 +1319,14 @@ mod tests {
         assert_eq!(&result, &target);
         let vector: Vec<I32F32> = vec_to_fixed(&vec![0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]);
         let result = is_topk(&vector, 0);
-        let target: Vec<bool> =
-            vec![false, false, false, false, false, false, false, false, false, false];
+        let target: Vec<bool> = vec![
+            false, false, false, false, false, false, false, false, false, false,
+        ];
         assert_eq!(&result, &target);
         let result = is_topk(&vector, 5);
-        let target: Vec<bool> =
-            vec![false, false, false, false, false, true, true, true, true, true];
+        let target: Vec<bool> = vec![
+            false, false, false, false, false, true, true, true, true, true,
+        ];
         assert_eq!(&result, &target);
         let result = is_topk(&vector, 10);
         let target: Vec<bool> = vec![true, true, true, true, true, true, true, true, true, true];
@@ -1306,24 +1335,28 @@ mod tests {
         assert_eq!(&result, &target);
         let vector: Vec<I32F32> = vec_to_fixed(&vec![9., 8., 7., 6., 5., 4., 3., 2., 1., 0.]);
         let result = is_topk(&vector, 5);
-        let target: Vec<bool> =
-            vec![true, true, true, true, true, false, false, false, false, false];
+        let target: Vec<bool> = vec![
+            true, true, true, true, true, false, false, false, false, false,
+        ];
         assert_eq!(&result, &target);
         let vector: Vec<I32F32> = vec_to_fixed(&vec![9., 0., 8., 1., 7., 2., 6., 3., 5., 4.]);
         let result = is_topk(&vector, 5);
-        let target: Vec<bool> =
-            vec![true, false, true, false, true, false, true, false, true, false];
+        let target: Vec<bool> = vec![
+            true, false, true, false, true, false, true, false, true, false,
+        ];
         assert_eq!(&result, &target);
         let vector: Vec<I32F32> =
             vec_to_fixed(&vec![0.9, 0., 0.8, 0.1, 0.7, 0.2, 0.6, 0.3, 0.5, 0.4]);
         let result = is_topk(&vector, 5);
-        let target: Vec<bool> =
-            vec![true, false, true, false, true, false, true, false, true, false];
+        let target: Vec<bool> = vec![
+            true, false, true, false, true, false, true, false, true, false,
+        ];
         assert_eq!(&result, &target);
         let vector: Vec<I32F32> = vec_to_fixed(&vec![0., 1., 2., 3., 4., 5., 5., 5., 5., 6.]);
         let result = is_topk(&vector, 5);
-        let target: Vec<bool> =
-            vec![false, false, false, false, false, true, true, true, true, true];
+        let target: Vec<bool> = vec![
+            false, false, false, false, false, true, true, true, true, true,
+        ];
         assert_eq!(&result, &target);
     }
 
@@ -1331,12 +1364,18 @@ mod tests {
     fn test_math_sum() {
         assert!(sum(&vec![]) == I32F32::from_num(0));
         assert!(
-            sum(&vec![I32F32::from_num(1.0), I32F32::from_num(10.0), I32F32::from_num(30.0)]) ==
-                I32F32::from_num(41)
+            sum(&vec![
+                I32F32::from_num(1.0),
+                I32F32::from_num(10.0),
+                I32F32::from_num(30.0)
+            ]) == I32F32::from_num(41)
         );
         assert!(
-            sum(&vec![I32F32::from_num(-1.0), I32F32::from_num(10.0), I32F32::from_num(30.0)]) ==
-                I32F32::from_num(39)
+            sum(&vec![
+                I32F32::from_num(-1.0),
+                I32F32::from_num(10.0),
+                I32F32::from_num(30.0)
+            ]) == I32F32::from_num(39)
         );
     }
 
@@ -1346,8 +1385,11 @@ mod tests {
         let x: Vec<I32F32> = vec![];
         let y: Vec<I32F32> = normalize(&x);
         assert_vec_compare(&x, &y, epsilon);
-        let x: Vec<I32F32> =
-            vec![I32F32::from_num(1.0), I32F32::from_num(10.0), I32F32::from_num(30.0)];
+        let x: Vec<I32F32> = vec![
+            I32F32::from_num(1.0),
+            I32F32::from_num(10.0),
+            I32F32::from_num(30.0),
+        ];
         let y: Vec<I32F32> = normalize(&x);
         assert_vec_compare(
             &y,
@@ -1359,8 +1401,11 @@ mod tests {
             epsilon,
         );
         assert_float_compare(sum(&y), I32F32::from_num(1.0), epsilon);
-        let x: Vec<I32F32> =
-            vec![I32F32::from_num(-1.0), I32F32::from_num(10.0), I32F32::from_num(30.0)];
+        let x: Vec<I32F32> = vec![
+            I32F32::from_num(-1.0),
+            I32F32::from_num(10.0),
+            I32F32::from_num(30.0),
+        ];
         let y: Vec<I32F32> = normalize(&x);
         assert_vec_compare(
             &y,
@@ -1377,8 +1422,11 @@ mod tests {
     #[test]
     fn test_math_inplace_normalize() {
         let epsilon: I32F32 = I32F32::from_num(0.0001);
-        let mut x1: Vec<I32F32> =
-            vec![I32F32::from_num(1.0), I32F32::from_num(10.0), I32F32::from_num(30.0)];
+        let mut x1: Vec<I32F32> = vec![
+            I32F32::from_num(1.0),
+            I32F32::from_num(10.0),
+            I32F32::from_num(30.0),
+        ];
         inplace_normalize(&mut x1);
         assert_vec_compare(
             &x1,
@@ -1389,8 +1437,11 @@ mod tests {
             ],
             epsilon,
         );
-        let mut x2: Vec<I32F32> =
-            vec![I32F32::from_num(-1.0), I32F32::from_num(10.0), I32F32::from_num(30.0)];
+        let mut x2: Vec<I32F32> = vec![
+            I32F32::from_num(-1.0),
+            I32F32::from_num(10.0),
+            I32F32::from_num(30.0),
+        ];
         inplace_normalize(&mut x2);
         assert_vec_compare(
             &x2,
@@ -1406,8 +1457,11 @@ mod tests {
     #[test]
     fn test_math_inplace_normalize_64() {
         let epsilon: I64F64 = I64F64::from_num(0.0001);
-        let mut x1: Vec<I64F64> =
-            vec![I64F64::from_num(1.0), I64F64::from_num(10.0), I64F64::from_num(30.0)];
+        let mut x1: Vec<I64F64> = vec![
+            I64F64::from_num(1.0),
+            I64F64::from_num(10.0),
+            I64F64::from_num(30.0),
+        ];
         inplace_normalize_64(&mut x1);
         assert_vec_compare_64(
             &x1,
@@ -1418,8 +1472,11 @@ mod tests {
             ],
             epsilon,
         );
-        let mut x2: Vec<I64F64> =
-            vec![I64F64::from_num(-1.0), I64F64::from_num(10.0), I64F64::from_num(30.0)];
+        let mut x2: Vec<I64F64> = vec![
+            I64F64::from_num(-1.0),
+            I64F64::from_num(10.0),
+            I64F64::from_num(30.0),
+        ];
         inplace_normalize_64(&mut x2);
         assert_vec_compare_64(
             &x2,
@@ -1561,24 +1618,45 @@ mod tests {
 
     #[test]
     fn test_math_inplace_mask_matrix() {
-        let mask: Vec<Vec<bool>> =
-            vec![vec![false, false, false], vec![false, false, false], vec![false, false, false]];
+        let mask: Vec<Vec<bool>> = vec![
+            vec![false, false, false],
+            vec![false, false, false],
+            vec![false, false, false],
+        ];
         let vector: Vec<f32> = vec![0., 1., 2., 3., 4., 5., 6., 7., 8.];
         let mut mat = vec_to_mat_fixed(&vector, 3, false);
         inplace_mask_matrix(&mask, &mut mat);
-        assert_mat_compare(&mat, &vec_to_mat_fixed(&vector, 3, false), I32F32::from_num(0));
-        let mask: Vec<Vec<bool>> =
-            vec![vec![true, false, false], vec![false, true, false], vec![false, false, true]];
+        assert_mat_compare(
+            &mat,
+            &vec_to_mat_fixed(&vector, 3, false),
+            I32F32::from_num(0),
+        );
+        let mask: Vec<Vec<bool>> = vec![
+            vec![true, false, false],
+            vec![false, true, false],
+            vec![false, false, true],
+        ];
         let target: Vec<f32> = vec![0., 1., 2., 3., 0., 5., 6., 7., 0.];
         let mut mat = vec_to_mat_fixed(&vector, 3, false);
         inplace_mask_matrix(&mask, &mut mat);
-        assert_mat_compare(&mat, &vec_to_mat_fixed(&target, 3, false), I32F32::from_num(0));
-        let mask: Vec<Vec<bool>> =
-            vec![vec![true, true, true], vec![true, true, true], vec![true, true, true]];
+        assert_mat_compare(
+            &mat,
+            &vec_to_mat_fixed(&target, 3, false),
+            I32F32::from_num(0),
+        );
+        let mask: Vec<Vec<bool>> = vec![
+            vec![true, true, true],
+            vec![true, true, true],
+            vec![true, true, true],
+        ];
         let target: Vec<f32> = vec![0., 0., 0., 0., 0., 0., 0., 0., 0.];
         let mut mat = vec_to_mat_fixed(&vector, 3, false);
         inplace_mask_matrix(&mask, &mut mat);
-        assert_mat_compare(&mat, &vec_to_mat_fixed(&target, 3, false), I32F32::from_num(0));
+        assert_mat_compare(
+            &mat,
+            &vec_to_mat_fixed(&target, 3, false),
+            I32F32::from_num(0),
+        );
     }
 
     #[test]
@@ -1588,23 +1666,39 @@ mod tests {
         let target: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9.];
         let mut mat = vec_to_mat_fixed(&input, 3, false);
         inplace_mask_rows(&mask, &mut mat);
-        assert_mat_compare(&mat, &vec_to_mat_fixed(&target, 3, false), I32F32::from_num(0));
+        assert_mat_compare(
+            &mat,
+            &vec_to_mat_fixed(&target, 3, false),
+            I32F32::from_num(0),
+        );
         let mask: Vec<bool> = vec![true, true, true];
         let target: Vec<f32> = vec![0., 0., 0., 0., 0., 0., 0., 0., 0.];
         let mut mat = vec_to_mat_fixed(&input, 3, false);
         inplace_mask_rows(&mask, &mut mat);
-        assert_mat_compare(&mat, &vec_to_mat_fixed(&target, 3, false), I32F32::from_num(0));
+        assert_mat_compare(
+            &mat,
+            &vec_to_mat_fixed(&target, 3, false),
+            I32F32::from_num(0),
+        );
         let mask: Vec<bool> = vec![true, false, true];
         let target: Vec<f32> = vec![0., 0., 0., 4., 5., 6., 0., 0., 0.];
         let mut mat = vec_to_mat_fixed(&input, 3, false);
         inplace_mask_rows(&mask, &mut mat);
-        assert_mat_compare(&mat, &vec_to_mat_fixed(&target, 3, false), I32F32::from_num(0));
+        assert_mat_compare(
+            &mat,
+            &vec_to_mat_fixed(&target, 3, false),
+            I32F32::from_num(0),
+        );
         let input: Vec<f32> = vec![0., 0., 0., 0., 0., 0., 0., 0., 0.];
         let mut mat = vec_to_mat_fixed(&input, 3, false);
         let mask: Vec<bool> = vec![false, false, false];
         let target: Vec<f32> = vec![0., 0., 0., 0., 0., 0., 0., 0., 0.];
         inplace_mask_rows(&mask, &mut mat);
-        assert_mat_compare(&mat, &vec_to_mat_fixed(&target, 3, false), I32F32::from_num(0));
+        assert_mat_compare(
+            &mat,
+            &vec_to_mat_fixed(&target, 3, false),
+            I32F32::from_num(0),
+        );
     }
 
     #[test]
@@ -1613,7 +1707,11 @@ mod tests {
         let target: Vec<f32> = vec![0., 2., 3., 4., 0., 6., 7., 8., 0.];
         let mut mat = vec_to_mat_fixed(&vector, 3, false);
         inplace_mask_diag(&mut mat);
-        assert_mat_compare(&mat, &vec_to_mat_fixed(&target, 3, false), I32F32::from_num(0));
+        assert_mat_compare(
+            &mat,
+            &vec_to_mat_fixed(&target, 3, false),
+            I32F32::from_num(0),
+        );
     }
 
     #[test]
@@ -1932,8 +2030,12 @@ mod tests {
         let matrix = vec_to_sparse_mat_fixed(&matrix, 4, false);
         let target: Vec<f32> = vec![0., 1., 1., 1., 1., 1., 1., 100., 100., 100., 100., 100.];
         let target = vec_to_sparse_mat_fixed(&target, 4, false);
-        let result =
-            clip_sparse(&matrix, I32F32::from_num(8), I32F32::from_num(100), I32F32::from_num(1));
+        let result = clip_sparse(
+            &matrix,
+            I32F32::from_num(8),
+            I32F32::from_num(100),
+            I32F32::from_num(1),
+        );
         assert_sparse_mat_compare(&result, &target, I32F32::from_num(0));
     }
 
@@ -1943,7 +2045,12 @@ mod tests {
         let matrix = vec_to_mat_fixed(&matrix, 4, false);
         let target: Vec<f32> = vec![1., 1., 1., 1., 1., 1., 1., 100., 100., 100., 100., 100.];
         let target = vec_to_mat_fixed(&target, 4, false);
-        let result = clip(&matrix, I32F32::from_num(8), I32F32::from_num(100), I32F32::from_num(1));
+        let result = clip(
+            &matrix,
+            I32F32::from_num(8),
+            I32F32::from_num(100),
+            I32F32::from_num(1),
+        );
         assert_mat_compare(&result, &target, I32F32::from_num(0));
     }
 
@@ -1953,7 +2060,12 @@ mod tests {
         let mut matrix = vec_to_mat_fixed(&matrix, 4, false);
         let target: Vec<f32> = vec![1., 1., 1., 1., 1., 1., 1., 100., 100., 100., 100., 100.];
         let target = vec_to_mat_fixed(&target, 4, false);
-        inplace_clip(&mut matrix, I32F32::from_num(8), I32F32::from_num(100), I32F32::from_num(1));
+        inplace_clip(
+            &mut matrix,
+            I32F32::from_num(8),
+            I32F32::from_num(100),
+            I32F32::from_num(1),
+        );
         assert_mat_compare(&matrix, &target, I32F32::from_num(0));
     }
 
@@ -2201,7 +2313,7 @@ mod tests {
                                 if median_stake == minority && !medians.contains(&score[i]) {
                                     medians.push(score[i]);
                                 }
-                                break
+                                break;
                             }
                             if !medians.contains(&score[i]) {
                                 medians.push(score[i]);
@@ -2270,37 +2382,58 @@ mod tests {
         let stake: Vec<I32F32> = vec_to_fixed(&vec![]);
         let weights: Vec<Vec<(u16, I32F32)>> = vec![vec![]];
         let median: Vec<I32F32> = vec_to_fixed(&vec![]);
-        assert_eq!(median, weighted_median_col_sparse(&stake, &weights, 0, fixed(0.5)));
+        assert_eq!(
+            median,
+            weighted_median_col_sparse(&stake, &weights, 0, fixed(0.5))
+        );
 
         let stake: Vec<I32F32> = vec_to_fixed(&vec![0., 0.]);
         let weights: Vec<f32> = vec![0., 0., 0., 0.];
         let weights: Vec<Vec<(u16, I32F32)>> = vec_to_sparse_mat_fixed(&weights, 2, false);
         let median: Vec<I32F32> = vec_to_fixed(&vec![0., 0.]);
-        assert_eq!(median, weighted_median_col_sparse(&stake, &weights, 2, fixed(0.5)));
+        assert_eq!(
+            median,
+            weighted_median_col_sparse(&stake, &weights, 2, fixed(0.5))
+        );
 
         let stake: Vec<I32F32> = vec_to_fixed(&vec![0., 0.75, 0.25, 0.]);
         let weights: Vec<f32> = vec![0., 0.1, 0., 0., 0.2, 0.4, 0., 0.3, 0.1, 0., 0.4, 0.5];
         let weights: Vec<Vec<(u16, I32F32)>> = vec_to_sparse_mat_fixed(&weights, 4, false);
         let median: Vec<I32F32> = vec_to_fixed(&vec![0., 0.3, 0.4]);
-        assert_eq!(median, weighted_median_col_sparse(&stake, &weights, 3, fixed(0.24)));
+        assert_eq!(
+            median,
+            weighted_median_col_sparse(&stake, &weights, 3, fixed(0.24))
+        );
         let median: Vec<I32F32> = vec_to_fixed(&vec![0., 0.2, 0.4]);
-        assert_eq!(median, weighted_median_col_sparse(&stake, &weights, 3, fixed(0.26)));
+        assert_eq!(
+            median,
+            weighted_median_col_sparse(&stake, &weights, 3, fixed(0.26))
+        );
         let median: Vec<I32F32> = vec_to_fixed(&vec![0., 0.2, 0.1]);
-        assert_eq!(median, weighted_median_col_sparse(&stake, &weights, 3, fixed(0.76)));
+        assert_eq!(
+            median,
+            weighted_median_col_sparse(&stake, &weights, 3, fixed(0.76))
+        );
 
         let stake: Vec<I32F32> = vec_to_fixed(&vec![0., 0.3, 0.2, 0.5]);
         let weights: Vec<f32> = vec![0., 0.1, 0., 0., 0.2, 0.4, 0., 0.3, 0.1, 0., 0., 0.5];
         let weights: Vec<Vec<(u16, I32F32)>> = vec_to_sparse_mat_fixed(&weights, 4, false);
         let median: Vec<I32F32> = vec_to_fixed(&vec![0., 0., 0.4]);
-        assert_eq!(median, weighted_median_col_sparse(&stake, &weights, 3, fixed(0.51)));
+        assert_eq!(
+            median,
+            weighted_median_col_sparse(&stake, &weights, 3, fixed(0.51))
+        );
     }
 
     #[test]
     fn test_math_hadamard() {
         let mat2: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.];
-        let mat1: Vec<f32> = vec![10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.];
-        let target: Vec<f32> =
-            vec![10., 40., 90., 160., 250., 360., 490., 640., 810., 1000., 1210., 1440.];
+        let mat1: Vec<f32> = vec![
+            10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.,
+        ];
+        let target: Vec<f32> = vec![
+            10., 40., 90., 160., 250., 360., 490., 640., 810., 1000., 1210., 1440.,
+        ];
         let mat2 = vec_to_mat_fixed(&mat2, 4, false);
         let mat1 = vec_to_mat_fixed(&mat1, 4, false);
         let target = vec_to_mat_fixed(&target, 4, false);
@@ -2327,9 +2460,12 @@ mod tests {
     #[test]
     fn test_math_hadamard_sparse() {
         let mat2: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.];
-        let mat1: Vec<f32> = vec![10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.];
-        let target: Vec<f32> =
-            vec![10., 40., 90., 160., 250., 360., 490., 640., 810., 1000., 1210., 1440.];
+        let mat1: Vec<f32> = vec![
+            10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.,
+        ];
+        let target: Vec<f32> = vec![
+            10., 40., 90., 160., 250., 360., 490., 640., 810., 1000., 1210., 1440.,
+        ];
         let mat2 = vec_to_sparse_mat_fixed(&mat2, 4, false);
         let mat1 = vec_to_sparse_mat_fixed(&mat1, 4, false);
         let target = vec_to_sparse_mat_fixed(&target, 4, false);
@@ -2356,16 +2492,21 @@ mod tests {
     #[test]
     fn test_math_mat_ema() {
         let old: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.];
-        let new: Vec<f32> = vec![10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.];
-        let target: Vec<f32> =
-            vec![1.9, 3.8, 5.7, 7.6, 9.5, 11.4, 13.3, 15.2, 17.1, 19., 20.9, 22.8];
+        let new: Vec<f32> = vec![
+            10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.,
+        ];
+        let target: Vec<f32> = vec![
+            1.9, 3.8, 5.7, 7.6, 9.5, 11.4, 13.3, 15.2, 17.1, 19., 20.9, 22.8,
+        ];
         let old = vec_to_mat_fixed(&old, 4, false);
         let new = vec_to_mat_fixed(&new, 4, false);
         let target = vec_to_mat_fixed(&target, 4, false);
         let result = mat_ema(&new, &old, I32F32::from_num(0.1));
         assert_mat_compare(&result, &target, I32F32::from_num(0.000001));
         let old: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.];
-        let new: Vec<f32> = vec![10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.];
+        let new: Vec<f32> = vec![
+            10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.,
+        ];
         let target: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.];
         let old = vec_to_mat_fixed(&old, 4, false);
         let new = vec_to_mat_fixed(&new, 4, false);
@@ -2373,8 +2514,12 @@ mod tests {
         let result = mat_ema(&new, &old, I32F32::from_num(0));
         assert_mat_compare(&result, &target, I32F32::from_num(0.000001));
         let old: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.];
-        let new: Vec<f32> = vec![10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.];
-        let target: Vec<f32> = vec![10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.];
+        let new: Vec<f32> = vec![
+            10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.,
+        ];
+        let target: Vec<f32> = vec![
+            10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.,
+        ];
         let old = vec_to_mat_fixed(&old, 4, false);
         let new = vec_to_mat_fixed(&new, 4, false);
         let target = vec_to_mat_fixed(&target, 4, false);
@@ -2385,9 +2530,12 @@ mod tests {
     #[test]
     fn test_math_sparse_mat_ema() {
         let old: Vec<f32> = vec![1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.];
-        let new: Vec<f32> = vec![10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.];
-        let target: Vec<f32> =
-            vec![1.9, 3.8, 5.7, 7.6, 9.5, 11.4, 13.3, 15.2, 17.1, 19., 20.9, 22.8];
+        let new: Vec<f32> = vec![
+            10., 20., 30., 40., 50., 60., 70., 80., 90., 100., 110., 120.,
+        ];
+        let target: Vec<f32> = vec![
+            1.9, 3.8, 5.7, 7.6, 9.5, 11.4, 13.3, 15.2, 17.1, 19., 20.9, 22.8,
+        ];
         let old = vec_to_sparse_mat_fixed(&old, 4, false);
         let new = vec_to_sparse_mat_fixed(&new, 4, false);
         let target = vec_to_sparse_mat_fixed(&target, 4, false);
@@ -2433,43 +2581,75 @@ mod tests {
         let w: Vec<Vec<I32F32>> = vec![vec![I32F32::from_num(1.0); 3]; 3];
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(1.0); 3]),
-            &vec![I32F32::from_num(3), I32F32::from_num(3), I32F32::from_num(3)],
+            &vec![
+                I32F32::from_num(3),
+                I32F32::from_num(3),
+                I32F32::from_num(3),
+            ],
             epsilon,
         );
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(2.0); 3]),
-            &vec![I32F32::from_num(6), I32F32::from_num(6), I32F32::from_num(6)],
+            &vec![
+                I32F32::from_num(6),
+                I32F32::from_num(6),
+                I32F32::from_num(6),
+            ],
             epsilon,
         );
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(3.0); 3]),
-            &vec![I32F32::from_num(9), I32F32::from_num(9), I32F32::from_num(9)],
+            &vec![
+                I32F32::from_num(9),
+                I32F32::from_num(9),
+                I32F32::from_num(9),
+            ],
             epsilon,
         );
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(-1.0); 3]),
-            &vec![I32F32::from_num(-3), I32F32::from_num(-3), I32F32::from_num(-3)],
+            &vec![
+                I32F32::from_num(-3),
+                I32F32::from_num(-3),
+                I32F32::from_num(-3),
+            ],
             epsilon,
         );
         let w: Vec<Vec<I32F32>> = vec![vec![I32F32::from_num(-1.0); 3]; 3];
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(1.0); 3]),
-            &vec![I32F32::from_num(-3), I32F32::from_num(-3), I32F32::from_num(-3)],
+            &vec![
+                I32F32::from_num(-3),
+                I32F32::from_num(-3),
+                I32F32::from_num(-3),
+            ],
             epsilon,
         );
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(2.0); 3]),
-            &vec![I32F32::from_num(-6), I32F32::from_num(-6), I32F32::from_num(-6)],
+            &vec![
+                I32F32::from_num(-6),
+                I32F32::from_num(-6),
+                I32F32::from_num(-6),
+            ],
             epsilon,
         );
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(3.0); 3]),
-            &vec![I32F32::from_num(-9), I32F32::from_num(-9), I32F32::from_num(-9)],
+            &vec![
+                I32F32::from_num(-9),
+                I32F32::from_num(-9),
+                I32F32::from_num(-9),
+            ],
             epsilon,
         );
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(-1.0); 3]),
-            &vec![I32F32::from_num(3), I32F32::from_num(3), I32F32::from_num(3)],
+            &vec![
+                I32F32::from_num(3),
+                I32F32::from_num(3),
+                I32F32::from_num(3),
+            ],
             epsilon,
         );
         let w: Vec<Vec<I32F32>> = vec![
@@ -2479,24 +2659,46 @@ mod tests {
         ];
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(0.0); 3]),
-            &vec![I32F32::from_num(0.0), I32F32::from_num(0.0), I32F32::from_num(0.0)],
+            &vec![
+                I32F32::from_num(0.0),
+                I32F32::from_num(0.0),
+                I32F32::from_num(0.0),
+            ],
             epsilon,
         );
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(2.0); 3]),
-            &vec![I32F32::from_num(12), I32F32::from_num(12), I32F32::from_num(12)],
+            &vec![
+                I32F32::from_num(12),
+                I32F32::from_num(12),
+                I32F32::from_num(12),
+            ],
             epsilon,
         );
-        let w: Vec<Vec<I32F32>> =
-            vec![vec![I32F32::from_num(1), I32F32::from_num(2), I32F32::from_num(3)]; 3];
+        let w: Vec<Vec<I32F32>> = vec![
+            vec![
+                I32F32::from_num(1),
+                I32F32::from_num(2),
+                I32F32::from_num(3)
+            ];
+            3
+        ];
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(0.0); 3]),
-            &vec![I32F32::from_num(0.0), I32F32::from_num(0.0), I32F32::from_num(0.0)],
+            &vec![
+                I32F32::from_num(0.0),
+                I32F32::from_num(0.0),
+                I32F32::from_num(0.0),
+            ],
             epsilon,
         );
         assert_vec_compare(
             &matmul(&w, &vec![I32F32::from_num(2.0); 3]),
-            &vec![I32F32::from_num(6), I32F32::from_num(12), I32F32::from_num(18)],
+            &vec![
+                I32F32::from_num(6),
+                I32F32::from_num(12),
+                I32F32::from_num(18),
+            ],
             epsilon,
         );
     }
diff --git a/pallets/subspace/src/module.rs b/pallets/subspace/src/module.rs
index d01f4d767..00155b33f 100644
--- a/pallets/subspace/src/module.rs
+++ b/pallets/subspace/src/module.rs
@@ -45,9 +45,15 @@ impl<T: Config> Pallet<T> {
         let max_name_length = MaxNameLength::<T>::get() as usize;
 
         assert!(params.name.len() > 0);
-        ensure!(params.name.len() <= max_name_length, Error::<T>::ModuleNameTooLong);
+        ensure!(
+            params.name.len() <= max_name_length,
+            Error::<T>::ModuleNameTooLong
+        );
         assert!(params.address.len() > 0);
-        ensure!(params.address.len() <= max_name_length, Error::<T>::ModuleAddressTooLong);
+        ensure!(
+            params.address.len() <= max_name_length,
+            Error::<T>::ModuleAddressTooLong
+        );
 
         Ok(())
     }
@@ -100,7 +106,7 @@ impl<T: Config> Pallet<T> {
         let n = Self::get_subnet_n(netuid);
         if n == 0 {
             // No modules in the network.
-            return
+            return;
         }
         let uid_key: T::AccountId = Keys::<T>::get(netuid, uid);
         let replace_uid = n - 1;
@@ -190,7 +196,12 @@ impl<T: Config> Pallet<T> {
         // 1. Get the next uid. This is always equal to subnetwork_n.
         let uid: u16 = Self::get_subnet_n(netuid);
         let block_number = Self::get_current_block_as_u64();
-        log::debug!("append_module( netuid: {:?} | uid: {:?} | new_key: {:?} ) ", netuid, key, uid);
+        log::debug!(
+            "append_module( netuid: {:?} | uid: {:?} | new_key: {:?} ) ",
+            netuid,
+            key,
+            uid
+        );
 
         // 3. Expand Yuma with new position.
         Emission::<T>::mutate(netuid, |v| v.push(0));
@@ -219,7 +230,7 @@ impl<T: Config> Pallet<T> {
 
     pub fn get_modules_stats(netuid: u16) -> Vec<ModuleStats<T>> {
         if !Self::if_subnet_exist(netuid) {
-            return Vec::new()
+            return Vec::new();
         }
 
         let mut modules = Vec::new();
@@ -244,7 +255,13 @@ impl<T: Config> Pallet<T> {
 
         let weights: Vec<(u16, u16)> = Weights::<T>::get(netuid, uid)
             .iter()
-            .filter_map(|(i, w)| if *w > 0 { Some(((*i).into(), (*w).into())) } else { None })
+            .filter_map(|(i, w)| {
+                if *w > 0 {
+                    Some(((*i).into(), (*w).into()))
+                } else {
+                    None
+                }
+            })
             .collect();
         let stake_from: Vec<(T::AccountId, u64)> = StakeFrom::<T>::get(netuid, key);
         let registration_block = Self::get_registration_block_for_uid(netuid, uid);
diff --git a/pallets/subspace/src/profit_share.rs b/pallets/subspace/src/profit_share.rs
index c7352317c..fa0d0b2de 100644
--- a/pallets/subspace/src/profit_share.rs
+++ b/pallets/subspace/src/profit_share.rs
@@ -12,7 +12,10 @@ impl<T: Config> Pallet<T> {
         let key = ensure_signed(origin)?;
 
         // needs to be registered as a network
-        ensure!(Self::is_key_registered_on_any_network(&key), Error::<T>::NotRegistered);
+        ensure!(
+            Self::is_key_registered_on_any_network(&key),
+            Error::<T>::NotRegistered
+        );
         assert!(keys.len() > 0);
         assert!(keys.len() == shares.len()); // make sure the keys and shares are the same length
 
diff --git a/pallets/subspace/src/registration.rs b/pallets/subspace/src/registration.rs
index b89c34e64..f3752f89a 100644
--- a/pallets/subspace/src/registration.rs
+++ b/pallets/subspace/src/registration.rs
@@ -55,7 +55,10 @@ impl<T: Config> Pallet<T> {
         );
 
         // --- 6. Ensure the module key is not already registered.
-        ensure!(!Self::key_registered(netuid, &key), Error::<T>::KeyAlreadyRegistered);
+        ensure!(
+            !Self::key_registered(netuid, &key),
+            Error::<T>::KeyAlreadyRegistered
+        );
 
         // --- 7. Check if we are exceeding the max allowed modules per network.
         // If we do deregister slot.
@@ -87,13 +90,19 @@ impl<T: Config> Pallet<T> {
         // --- 1. Check that the caller has signed the transaction.
         let key = ensure_signed(origin.clone())?;
 
-        ensure!(Self::key_registered(netuid, &key), Error::<T>::NotRegistered);
+        ensure!(
+            Self::key_registered(netuid, &key),
+            Error::<T>::NotRegistered
+        );
 
         // --- 2. Ensure we are not exceeding the max allowed registrations per block.
         let uid: u16 = Self::get_uid_for_key(netuid, &key);
 
         Self::remove_module(netuid, uid);
-        ensure!(!Self::key_registered(netuid, &key), Error::<T>::StillRegistered);
+        ensure!(
+            !Self::key_registered(netuid, &key),
+            Error::<T>::StillRegistered
+        );
 
         // --- 5. Ok and done.
         Ok(())
@@ -144,7 +153,7 @@ impl<T: Config> Pallet<T> {
                     lowest_priority_uid = module_uid_i;
                     min_score = pruning_score;
                     if min_score == 0 {
-                        break
+                        break;
                     }
                 }
             }
@@ -192,7 +201,10 @@ impl<T: Config> Pallet<T> {
             let least_staked_netuid: u16 = Self::least_staked_netuid();
 
             // deregister the lowest priority node
-            Self::remove_module(least_staked_netuid, Self::get_lowest_uid(least_staked_netuid));
+            Self::remove_module(
+                least_staked_netuid,
+                Self::get_lowest_uid(least_staked_netuid),
+            );
 
         // if we reach the max allowed modules for this network,
         // then we replace the lowest priority node
diff --git a/pallets/subspace/src/staking.rs b/pallets/subspace/src/staking.rs
index 402e6c566..3c249d6de 100644
--- a/pallets/subspace/src/staking.rs
+++ b/pallets/subspace/src/staking.rs
@@ -15,8 +15,14 @@ impl<T: Config> Pallet<T> {
     ) -> dispatch::DispatchResult {
         let key = ensure_signed(origin.clone())?;
         let amounts_sum: u64 = amounts.iter().sum();
-        ensure!(Self::has_enough_balance(&key, amounts_sum), Error::<T>::NotEnoughStaketoWithdraw);
-        ensure!(amounts.len() == module_keys.len(), Error::<T>::DifferentLengths);
+        ensure!(
+            Self::has_enough_balance(&key, amounts_sum),
+            Error::<T>::NotEnoughStaketoWithdraw
+        );
+        ensure!(
+            amounts.len() == module_keys.len(),
+            Error::<T>::DifferentLengths
+        );
 
         for (i, m_key) in module_keys.iter().enumerate() {
             Self::do_add_stake(origin.clone(), netuid, m_key.clone(), amounts[i as usize])?;
@@ -35,7 +41,10 @@ impl<T: Config> Pallet<T> {
             Self::has_enough_balance(&key, amounts_sum),
             Error::<T>::NotEnoughBalanceToTransfer
         );
-        ensure!(amounts.len() == destinations.len(), Error::<T>::DifferentLengths);
+        ensure!(
+            amounts.len() == destinations.len(),
+            Error::<T>::DifferentLengths
+        );
 
         for (i, m_key) in destinations.iter().enumerate() {
             ensure!(
@@ -54,7 +63,10 @@ impl<T: Config> Pallet<T> {
         amounts: Vec<u64>,
     ) -> dispatch::DispatchResult {
         let key = ensure_signed(origin.clone())?;
-        ensure!(amounts.len() == module_keys.len(), Error::<T>::DifferentLengths);
+        ensure!(
+            amounts.len() == module_keys.len(),
+            Error::<T>::DifferentLengths
+        );
 
         for (i, m_key) in module_keys.iter().enumerate() {
             ensure!(
@@ -74,8 +86,14 @@ impl<T: Config> Pallet<T> {
         amount: u64,
     ) -> dispatch::DispatchResult {
         let key = ensure_signed(origin.clone())?;
-        ensure!(Self::is_registered(netuid, &module_key.clone()), Error::<T>::NotRegistered);
-        ensure!(Self::is_registered(netuid, &new_module_key.clone()), Error::<T>::NotRegistered);
+        ensure!(
+            Self::is_registered(netuid, &module_key.clone()),
+            Error::<T>::NotRegistered
+        );
+        ensure!(
+            Self::is_registered(netuid, &new_module_key.clone()),
+            Error::<T>::NotRegistered
+        );
         ensure!(
             Self::has_enough_stake(netuid, &key, &module_key, amount),
             Error::<T>::NotEnoughStaketoWithdraw
@@ -100,9 +118,15 @@ impl<T: Config> Pallet<T> {
         // --- 1. Ensure we don't exceed tx rate limit
         // ensure!( !Self::exceeds_tx_rate_limit(&key), Error::<T>::TxRateLimitExceeded);
 
-        ensure!(Self::is_registered(netuid, &module_key.clone()), Error::<T>::NotRegistered);
+        ensure!(
+            Self::is_registered(netuid, &module_key.clone()),
+            Error::<T>::NotRegistered
+        );
 
-        ensure!(Self::has_enough_balance(&key, amount), Error::<T>::NotEnoughBalanceToStake);
+        ensure!(
+            Self::has_enough_balance(&key, amount),
+            Error::<T>::NotEnoughBalanceToStake
+        );
 
         let stake_before_add: u64 = Self::get_stake_to_module(netuid, &key, &module_key.clone());
         let balance_before_add: u64 = Self::get_balance_u64(&key);
@@ -146,7 +170,10 @@ impl<T: Config> Pallet<T> {
         // information.
         let key = ensure_signed(origin)?;
 
-        ensure!(Self::is_registered(netuid, &module_key.clone()), Error::<T>::NotRegistered);
+        ensure!(
+            Self::is_registered(netuid, &module_key.clone()),
+            Error::<T>::NotRegistered
+        );
 
         // --- 6. Ensure we don't exceed tx rate limit
         // ensure!( !Self::exceeds_tx_rate_limit(&key), Error::<T>::TxRateLimitExceeded );
@@ -157,7 +184,10 @@ impl<T: Config> Pallet<T> {
             Error::<T>::NotEnoughStaketoWithdraw
         );
         let stake_to_be_added_as_currency = Self::u64_to_balance(amount);
-        ensure!(stake_to_be_added_as_currency.is_some(), Error::<T>::CouldNotConvertToBalance);
+        ensure!(
+            stake_to_be_added_as_currency.is_some(),
+            Error::<T>::CouldNotConvertToBalance
+        );
 
         let stake_before_remove: u64 = Self::get_stake_to_module(netuid, &key, &module_key.clone());
         let balance_before_remove: u64 = Self::get_balance_u64(&key);
@@ -280,7 +310,7 @@ impl<T: Config> Pallet<T> {
         // and can bloat the chain
         if stake_to_vector.len() == 0 {
             StakeTo::<T>::remove(netuid, key);
-            return
+            return;
         }
         StakeTo::<T>::insert(netuid, key, stake_to_vector);
     }
@@ -400,7 +430,7 @@ impl<T: Config> Pallet<T> {
                     // we need to remove this entry if its zero
                     idx_to_replace = i;
                 }
-                break
+                break;
             }
         }
         if idx_to_replace != usize::MAX {
@@ -422,7 +452,7 @@ impl<T: Config> Pallet<T> {
                 if remaining_stake == 0 {
                     idx_to_replace = i;
                 }
-                break
+                break;
             }
         }
 
@@ -505,12 +535,12 @@ impl<T: Config> Pallet<T> {
     pub fn can_remove_balance_from_account(key: &T::AccountId, amount_64: u64) -> bool {
         let amount_as_balance = Self::u64_to_balance(amount_64);
         if amount_as_balance.is_none() {
-            return false
+            return false;
         }
         let amount = amount_as_balance.unwrap();
         let current_balance = Self::get_balance(key);
         if amount > current_balance {
-            return false
+            return false;
         }
         // This bit is currently untested. @todo
         let new_potential_balance = current_balance - amount;
diff --git a/pallets/subspace/src/step.rs b/pallets/subspace/src/step.rs
index 5d35601a2..208696dc7 100644
--- a/pallets/subspace/src/step.rs
+++ b/pallets/subspace/src/step.rs
@@ -12,9 +12,13 @@ impl<T: Config> Pallet<T> {
         for (netuid, tempo) in <Tempo<T> as IterableStorageMap<u16, u16>>::iter() {
             let new_queued_emission: u64 = Self::calculate_network_emission(netuid);
             PendingEmission::<T>::mutate(netuid, |queued| *queued += new_queued_emission);
-            log::debug!("netuid_i: {:?} queued_emission: +{:?} ", netuid, new_queued_emission);
+            log::debug!(
+                "netuid_i: {:?} queued_emission: +{:?} ",
+                netuid,
+                new_queued_emission
+            );
             if Self::blocks_until_next_epoch(netuid, tempo, block_number) > 0 {
-                continue
+                continue;
             }
             let emission_to_drain: u64 = PendingEmission::<T>::get(netuid).clone();
             Self::epoch(netuid, emission_to_drain);
@@ -34,7 +38,7 @@ impl<T: Config> Pallet<T> {
 
         if n == 0 {
             //
-            return
+            return;
         }
 
         // FOUNDER DIVIDENDS
@@ -110,8 +114,8 @@ impl<T: Config> Pallet<T> {
                     if (pos as u16) <= subnet_params.max_allowed_weights && *uid_j < n {
                         // okay , we passed the positioonal check, now check the weight
                         let weight_f64 = I64F64::from_num(*weight_ij) / I64F64::from_num(u16::MAX);
-                        let weight_stake = (stake_f64[uid_i as usize] * weight_f64) *
-                            I64F64::from_num(total_stake_u64);
+                        let weight_stake = (stake_f64[uid_i as usize] * weight_f64)
+                            * I64F64::from_num(total_stake_u64);
                         if weight_stake > min_weight_stake_f64 {
                             weights[uid_i as usize].push((*uid_j, *weight_ij));
                         } else {
@@ -338,7 +342,7 @@ impl<T: Config> Pallet<T> {
                 let total_owner_dividends_emission: u64 = owner_dividends_emission;
                 for (delegate_key, delegate_ratio) in ownership_vector.iter() {
                     if delegate_key == module_key {
-                        continue
+                        continue;
                     }
 
                     let dividends_from_delegate: u64 =
@@ -395,7 +399,7 @@ impl<T: Config> Pallet<T> {
 
     pub fn blocks_until_next_epoch(netuid: u16, tempo: u16, block_number: u64) -> u64 {
         if tempo == 0 {
-            return 0
+            return 0;
         }
         (block_number + netuid as u64) % (tempo as u64)
     }
@@ -456,8 +460,8 @@ impl<T: Config> Pallet<T> {
         let mut burn_amount_per_epoch: u64 = 0;
         // get the float and convert to u64token_emission
         if burn_rate > 0 {
-            let burn_rate_float: I64F64 = (I64F64::from_num(burn_rate) / I64F64::from_num(100)) *
-                (I64F64::from_num(token_emission) / I64F64::from_num(n));
+            let burn_rate_float: I64F64 = (I64F64::from_num(burn_rate) / I64F64::from_num(100))
+                * (I64F64::from_num(token_emission) / I64F64::from_num(n));
             burn_amount_per_epoch = burn_rate_float.to_num::<u64>();
         }
         burn_amount_per_epoch
diff --git a/pallets/subspace/src/subnet.rs b/pallets/subspace/src/subnet.rs
index 08b046261..728bf5621 100644
--- a/pallets/subspace/src/subnet.rs
+++ b/pallets/subspace/src/subnet.rs
@@ -18,8 +18,14 @@ impl<T: Config> Pallet<T> {
         let key = ensure_signed(origin)?;
         // --- 1. Ensure the network name does not already exist.
 
-        ensure!(Self::if_subnet_netuid_exists(netuid), Error::<T>::SubnetNameAlreadyExists);
-        ensure!(Self::is_subnet_founder(netuid, &key), Error::<T>::NotFounder);
+        ensure!(
+            Self::if_subnet_netuid_exists(netuid),
+            Error::<T>::SubnetNameAlreadyExists
+        );
+        ensure!(
+            Self::is_subnet_founder(netuid, &key),
+            Error::<T>::NotFounder
+        );
 
         Self::remove_subnet(netuid);
         // --- 16. Ok and done.
@@ -34,11 +40,26 @@ impl<T: Config> Pallet<T> {
         let key = ensure_signed(origin)?;
         // only the founder can update the network on authority mode
 
-        ensure!(Self::get_vote_mode_subnet(netuid) == AUTHORITY_MODE, Error::<T>::NotAuthorityMode);
-        ensure!(Self::if_subnet_netuid_exists(netuid), Error::<T>::SubnetNameAlreadyExists);
-        ensure!(Self::is_subnet_founder(netuid, &key), Error::<T>::NotFounder);
-        ensure!(Self::if_subnet_netuid_exists(netuid), Error::<T>::SubnetNameAlreadyExists);
-        ensure!(Self::is_subnet_founder(netuid, &key), Error::<T>::NotFounder);
+        ensure!(
+            Self::get_vote_mode_subnet(netuid) == AUTHORITY_MODE,
+            Error::<T>::NotAuthorityMode
+        );
+        ensure!(
+            Self::if_subnet_netuid_exists(netuid),
+            Error::<T>::SubnetNameAlreadyExists
+        );
+        ensure!(
+            Self::is_subnet_founder(netuid, &key),
+            Error::<T>::NotFounder
+        );
+        ensure!(
+            Self::if_subnet_netuid_exists(netuid),
+            Error::<T>::SubnetNameAlreadyExists
+        );
+        ensure!(
+            Self::is_subnet_founder(netuid, &key),
+            Error::<T>::NotFounder
+        );
         Self::check_subnet_params(params.clone())?;
         Self::set_subnet_params(netuid, params);
         // --- 16. Ok and done.
@@ -64,7 +85,10 @@ impl<T: Config> Pallet<T> {
             Error::<T>::InvalidMinAllowedWeights
         );
 
-        ensure!(params.min_allowed_weights >= 1, Error::<T>::InvalidMinAllowedWeights);
+        ensure!(
+            params.min_allowed_weights >= 1,
+            Error::<T>::InvalidMinAllowedWeights
+        );
 
         ensure!(
             params.max_allowed_weights <= global_params.max_allowed_weights,
@@ -72,13 +96,22 @@ impl<T: Config> Pallet<T> {
         );
 
         // the  global params must be larger than the global min_stake
-        ensure!(params.min_stake >= global_params.min_stake, Error::<T>::InvalidMinStake);
+        ensure!(
+            params.min_stake >= global_params.min_stake,
+            Error::<T>::InvalidMinStake
+        );
 
-        ensure!(params.max_stake > params.min_stake, Error::<T>::InvalidMaxStake);
+        ensure!(
+            params.max_stake > params.min_stake,
+            Error::<T>::InvalidMaxStake
+        );
 
         ensure!(params.tempo > 0, Error::<T>::InvalidTempo);
 
-        ensure!(params.max_weight_age > params.tempo as u64, Error::<T>::InvalidMaxWeightAge);
+        ensure!(
+            params.max_weight_age > params.tempo as u64,
+            Error::<T>::InvalidMaxWeightAge
+        );
 
         // ensure the trust_ratio is between 0 and 100
         ensure!(params.trust_ratio <= 100, Error::<T>::InvalidTrustRatio);
@@ -312,7 +345,7 @@ impl<T: Config> Pallet<T> {
             let halving_factor = 2u64.pow((i) as u32);
             if market_cap < *having_stake {
                 emission_per_block = emission_per_block / halving_factor;
-                break
+                break;
             }
         }
 
@@ -320,7 +353,7 @@ impl<T: Config> Pallet<T> {
     }
     pub fn get_total_subnet_balance(netuid: u16) -> u64 {
         let keys = Self::get_keys(netuid);
-        return keys.iter().map(|x| Self::get_balance_u64(x)).sum()
+        return keys.iter().map(|x| Self::get_balance_u64(x)).sum();
     }
 
     pub fn calculate_network_emission(netuid: u16) -> u64 {
@@ -374,7 +407,7 @@ impl<T: Config> Pallet<T> {
     pub fn subnet_name_exists(name: Vec<u8>) -> bool {
         for (_netuid, _name) in <SubnetNames<T> as IterableStorageMap<u16, Vec<u8>>>::iter() {
             if _name == name {
-                return true
+                return true;
             }
         }
         false
@@ -421,7 +454,7 @@ impl<T: Config> Pallet<T> {
 
         // --- 2. Ensure the network to be removed exists.
         if !Self::if_subnet_exist(netuid) {
-            return 0
+            return 0;
         }
 
         Self::remove_netuid_stake_strorage(netuid);
@@ -501,7 +534,7 @@ impl<T: Config> Pallet<T> {
     pub fn is_key_registered_on_any_network(key: &T::AccountId) -> bool {
         for netuid in Self::netuids() {
             if Uids::<T>::contains_key(netuid, key) {
-                return true
+                return true;
             }
         }
         false
@@ -633,7 +666,7 @@ impl<T: Config> Pallet<T> {
         let n: u16 = Self::get_subnet_n(netuid);
         // get the float and convert to u64
         if n == 0 {
-            return 0
+            return 0;
         }
         let burn_rate_float: I64F64 = I64F64::from_num(burn_rate) / I64F64::from_num(n * 100);
         let burn_emission_per_epoch: u64 =
@@ -844,40 +877,40 @@ impl<T: Config> Pallet<T> {
         let last_update = Self::get_last_update(netuid);
 
         if (n as usize) != uids.len() {
-            return false
+            return false;
         }
         if (n as usize) != keys.len() {
-            return false
+            return false;
         }
         if (n as usize) != names.len() {
-            return false
+            return false;
         }
         if (n as usize) != addresses.len() {
-            return false
+            return false;
         }
         if (n as usize) != emissions.len() {
-            return false
+            return false;
         }
         if (n as usize) != incentives.len() {
-            return false
+            return false;
         }
         if (n as usize) != dividends.len() {
-            return false
+            return false;
         }
         if (n as usize) != last_update.len() {
-            return false
+            return false;
         }
 
         // length of addresss
         let name_vector = Self::name_vector(netuid);
         if (n as usize) != name_vector.len() {
-            return false
+            return false;
         }
 
         // length of addresss
         let address_vector = Self::address_vector(netuid);
         if (n as usize) != address_vector.len() {
-            return false
+            return false;
         }
 
         true
diff --git a/pallets/subspace/src/voting.rs b/pallets/subspace/src/voting.rs
index 223023aef..20399ef24 100644
--- a/pallets/subspace/src/voting.rs
+++ b/pallets/subspace/src/voting.rs
@@ -9,9 +9,15 @@ pub const AUTHORITY_MODE: &[u8] = b"authority";
 impl<T: Config> Pallet<T> {
     pub fn do_unregister_voter(origin: T::RuntimeOrigin) -> DispatchResult {
         let key = ensure_signed(origin)?;
-        ensure!(Self::is_voter_registered(&key), Error::<T>::VoterIsNotRegistered);
+        ensure!(
+            Self::is_voter_registered(&key),
+            Error::<T>::VoterIsNotRegistered
+        );
         Self::unregister_voter(&key);
-        ensure!(!Self::is_voter_registered(&key), Error::<T>::VoterIsRegistered);
+        ensure!(
+            !Self::is_voter_registered(&key),
+            Error::<T>::VoterIsRegistered
+        );
         Ok(())
     }
 
@@ -102,7 +108,10 @@ impl<T: Config> Pallet<T> {
     pub fn do_vote_proposal(origin: T::RuntimeOrigin, proposal_id: u64) -> DispatchResult {
         let key = ensure_signed(origin)?;
 
-        ensure!(Self::proposal_exists(proposal_id), Error::<T>::ProposalDoesNotExist);
+        ensure!(
+            Self::proposal_exists(proposal_id),
+            Error::<T>::ProposalDoesNotExist
+        );
 
         // if you vote the proposal on a subnet, you are no longer a participant
 
@@ -163,7 +172,7 @@ impl<T: Config> Pallet<T> {
                 if proposal.accepted || proposal.votes == 0 {
                     least_votes = 0;
                     least_voted_proposal_id = proposal_id;
-                    break
+                    break;
                 }
 
                 if proposal.votes < least_votes {
@@ -172,7 +181,10 @@ impl<T: Config> Pallet<T> {
                 }
             }
 
-            ensure!(proposal.votes > least_votes, Error::<T>::TooFewVotesForNewProposal);
+            ensure!(
+                proposal.votes > least_votes,
+                Error::<T>::TooFewVotesForNewProposal
+            );
 
             // remove proposal participants
             let proposal = Proposals::<T>::get(least_voted_proposal_id);
@@ -192,8 +204,11 @@ impl<T: Config> Pallet<T> {
                 Self::check_subnet_params(proposal.subnet_params.clone())?;
                 //  check if vote mode is valid
                 let subnet_params: SubnetParams<T> = Self::subnet_params(proposal.netuid);
-                ensure!(subnet_params.vote_mode == STAKE_MODE, Error::<T>::InvalidVoteMode);
-            },
+                ensure!(
+                    subnet_params.vote_mode == STAKE_MODE,
+                    Error::<T>::InvalidVoteMode
+                );
+            }
             _ => ensure!(proposal.data.len() > 0, Error::<T>::InvalidProposalData),
         }
 
diff --git a/pallets/subspace/src/weights.rs b/pallets/subspace/src/weights.rs
index 920031f87..acf72dc37 100644
--- a/pallets/subspace/src/weights.rs
+++ b/pallets/subspace/src/weights.rs
@@ -16,7 +16,10 @@ impl<T: Config> Pallet<T> {
         // check if the stake per weight is greater than the stake
         let min_stake_per_weight: u64 = Self::get_min_weight_stake();
         let min_stake_for_weights: u64 = min_stake_per_weight * uids.len() as u64;
-        ensure!(stake >= min_stake_for_weights, Error::<T>::NotEnoughtStakePerWeight);
+        ensure!(
+            stake >= min_stake_for_weights,
+            Error::<T>::NotEnoughtStakePerWeight
+        );
 
         ensure!(stake > 0, Error::<T>::NotEnoughStaketoSetWeights);
 
@@ -24,12 +27,21 @@ impl<T: Config> Pallet<T> {
 
         ensure!(stake > 0, Error::<T>::NotEnoughStaketoSetWeights);
         // --- 2. Check to see if this is a valid network.
-        ensure!(Self::if_subnet_exist(netuid), Error::<T>::NetworkDoesNotExist);
+        ensure!(
+            Self::if_subnet_exist(netuid),
+            Error::<T>::NetworkDoesNotExist
+        );
         // --- 5. Check to see if the key is registered to the passed network.
-        ensure!(Self::is_key_registered_on_network(netuid, &key), Error::<T>::NotRegistered);
+        ensure!(
+            Self::is_key_registered_on_network(netuid, &key),
+            Error::<T>::NotRegistered
+        );
 
         // --- 3. Check that the length of uid list and value list are equal for this network.
-        ensure!(Self::uids_match_values(&uids, &values), Error::<T>::WeightVecNotEqualSize);
+        ensure!(
+            Self::uids_match_values(&uids, &values),
+            Error::<T>::WeightVecNotEqualSize
+        );
 
         // --- 4. Check to see if the number of uids is within the max allowed uids for this
         // network. --- 7. Get the module uid of associated key on network netuid.
@@ -40,16 +52,28 @@ impl<T: Config> Pallet<T> {
         ensure!(!Self::has_duplicate_uids(&uids), Error::<T>::DuplicateUids);
 
         // --- 11. Ensure that the passed uids are valid for the network.
-        ensure!(!Self::contains_invalid_uids(netuid, &uids), Error::<T>::InvalidUid);
+        ensure!(
+            !Self::contains_invalid_uids(netuid, &uids),
+            Error::<T>::InvalidUid
+        );
 
         let min_allowed_length: usize = Self::get_min_allowed_weights(netuid) as usize;
         let max_allowed_length: usize = Self::get_max_allowed_weights(netuid) as usize;
         let self_vote = Self::get_self_vote(netuid);
         if self_vote {
-            ensure!(!Self::is_self_weight(uid, &uids, &values), Error::<T>::NoSelfWeight);
+            ensure!(
+                !Self::is_self_weight(uid, &uids, &values),
+                Error::<T>::NoSelfWeight
+            );
         }
-        ensure!(uids.len() >= min_allowed_length as usize, Error::<T>::NotSettingEnoughWeights);
-        ensure!(uids.len() <= max_allowed_length as usize, Error::<T>::TooManyUids);
+        ensure!(
+            uids.len() >= min_allowed_length as usize,
+            Error::<T>::NotSettingEnoughWeights
+        );
+        ensure!(
+            uids.len() <= max_allowed_length as usize,
+            Error::<T>::TooManyUids
+        );
 
         // --- 13. Normalize the weights.
         let normalized_values = Self::normalize_weights(values);
@@ -79,7 +103,7 @@ impl<T: Config> Pallet<T> {
     pub fn contains_invalid_uids(netuid: u16, uids: &Vec<u16>) -> bool {
         for uid in uids {
             if !Self::is_uid_exist_on_network(netuid, *uid) {
-                return true
+                return true;
             }
         }
         false
@@ -95,7 +119,7 @@ impl<T: Config> Pallet<T> {
         let mut parsed: Vec<u16> = Vec::new();
         for item in items {
             if parsed.contains(&item) {
-                return true
+                return true;
             }
             parsed.push(item.clone());
         }
@@ -108,15 +132,15 @@ impl<T: Config> Pallet<T> {
         let n: usize = Self::get_subnet_n(netuid) as usize;
         // Check self weight. Allowed to set single value for self weight.
         if Self::is_self_weight(uid, uids, weights) {
-            return true
+            return true;
         }
         // Check if number of weights exceeds min.
         if weights.len() >= min_allowed_length {
-            return true
+            return true;
         }
 
         if weights.len() > n {
-            return true
+            return true;
         }
         // To few weights.
         false
@@ -126,7 +150,7 @@ impl<T: Config> Pallet<T> {
     pub fn normalize_weights(mut weights: Vec<u16>) -> Vec<u16> {
         let sum: u64 = weights.iter().map(|x| *x as u64).sum();
         if sum == 0 {
-            return weights
+            return weights;
         }
         weights.iter_mut().for_each(|x| {
             *x = (*x as u64 * u16::max_value() as u64 / sum) as u16;
@@ -137,10 +161,10 @@ impl<T: Config> Pallet<T> {
     // Returns true if the uids and weights correspond to a self weight on the uid.
     pub fn is_self_weight(uid: u16, uids: &Vec<u16>, weights: &Vec<u16>) -> bool {
         if weights.len() != 1 {
-            return false
+            return false;
         }
         if uid != uids[0] {
-            return false
+            return false;
         }
         true
     }
@@ -149,10 +173,10 @@ impl<T: Config> Pallet<T> {
         let min_allowed_length: usize = Self::get_min_allowed_weights(netuid) as usize;
         let max_allowed_length: usize = Self::get_max_allowed_weights(netuid) as usize;
         if uids.len() > max_allowed_length as usize {
-            return false
+            return false;
         }
         if uids.len() < min_allowed_length as usize {
-            return false
+            return false;
         }
         true
     }
diff --git a/pallets/subspace/tests/test_burn.rs b/pallets/subspace/tests/test_burn.rs
index 4452674ba..cd7bb8dde 100644
--- a/pallets/subspace/tests/test_burn.rs
+++ b/pallets/subspace/tests/test_burn.rs
@@ -42,9 +42,20 @@ fn test_burn() {
                 votes.push(1);
                 uids.push(i as u16);
             }
-            println!("{:?}", SubspaceModule::get_stake_for_key(netuid, &voter_key));
-            assert_ok!(SubspaceModule::set_weights(get_origin(voter_key), netuid, uids, votes));
-            println!("burn : {:?}", SubspaceModule::get_burn_emission_per_epoch(netuid));
+            println!(
+                "{:?}",
+                SubspaceModule::get_stake_for_key(netuid, &voter_key)
+            );
+            assert_ok!(SubspaceModule::set_weights(
+                get_origin(voter_key),
+                netuid,
+                uids,
+                votes
+            ));
+            println!(
+                "burn : {:?}",
+                SubspaceModule::get_burn_emission_per_epoch(netuid)
+            );
 
             let _total_stake = SubspaceModule::get_total_subnet_stake(netuid);
 
@@ -91,9 +102,9 @@ fn test_burn() {
 
             let _calculated_subnet_emission = emissions.iter().sum::<u64>();
             let expected_subnet_emission: u64 =
-                ((SubspaceModule::get_subnet_emission(netuid) as f64 *
-                    (subnet_params.tempo as f64)) *
-                    (((100 - burn_rate) as f64) / 100.0)) as u64;
+                ((SubspaceModule::get_subnet_emission(netuid) as f64
+                    * (subnet_params.tempo as f64))
+                    * (((100 - burn_rate) as f64) / 100.0)) as u64;
 
             let delta_ratio = 0.01;
             let delta = (total_stake_before as f64 * delta_ratio) as u64;
@@ -101,8 +112,8 @@ fn test_burn() {
             let expected_subnet_emission =
                 total_stake_before.saturating_add(expected_subnet_emission);
             assert!(
-                total_stake_after.saturating_sub(delta) < expected_subnet_emission &&
-                    total_stake_after + delta > expected_subnet_emission,
+                total_stake_after.saturating_sub(delta) < expected_subnet_emission
+                    && total_stake_after + delta > expected_subnet_emission,
                 "total_stake_after: {:?} expected_subnet_emission: {:?}",
                 total_stake_after,
                 expected_subnet_emission
diff --git a/pallets/subspace/tests/test_delegate_staking.rs b/pallets/subspace/tests/test_delegate_staking.rs
index 9145074bd..3d2c26c9c 100644
--- a/pallets/subspace/tests/test_delegate_staking.rs
+++ b/pallets/subspace/tests/test_delegate_staking.rs
@@ -69,14 +69,17 @@ fn test_ownership_ratio() {
                 stake_per_module
             ));
             let stake_from_vector = SubspaceModule::get_stake_from_vector(netuid, &voter_key);
-            assert_eq!(stake_from_vector.len(), pre_delegate_stake_from_vector.len() + i + 1);
+            assert_eq!(
+                stake_from_vector.len(),
+                pre_delegate_stake_from_vector.len() + i + 1
+            );
         }
         let ownership_ratios: Vec<(U256, I64F64)> =
             SubspaceModule::get_ownership_ratios(netuid, &voter_key);
         assert_eq!(ownership_ratios.len(), delegate_keys.len() + 1);
 
-        let founder_tokens_before = SubspaceModule::get_balance(&voter_key) +
-            SubspaceModule::get_stake_to_module(netuid, &voter_key, &voter_key);
+        let founder_tokens_before = SubspaceModule::get_balance(&voter_key)
+            + SubspaceModule::get_stake_to_module(netuid, &voter_key, &voter_key);
 
         let delegate_balances_before =
             delegate_keys.iter().map(SubspaceModule::get_balance).collect::<Vec<u64>>();
@@ -120,7 +123,10 @@ fn test_ownership_ratio() {
 
         println!("delegate_balances before: {:?}", delegate_balances_before);
         println!("delegate_stakes before: {:?}", delegate_stakes_before);
-        println!("delegate_total_tokens before: {:?}", delegate_total_tokens_before);
+        println!(
+            "delegate_total_tokens before: {:?}",
+            delegate_total_tokens_before
+        );
 
         let result = SubspaceModule::set_weights(
             get_origin(voter_key),
@@ -155,8 +161,8 @@ fn test_ownership_ratio() {
             .zip(delegate_stakes.clone())
             .map(|(a, x)| a + x)
             .sum::<u64>();
-        let founder_tokens = SubspaceModule::get_balance(&voter_key) +
-            SubspaceModule::get_stake_to_module(netuid, &voter_key, &voter_key);
+        let founder_tokens = SubspaceModule::get_balance(&voter_key)
+            + SubspaceModule::get_stake_to_module(netuid, &voter_key, &voter_key);
         let founder_new_tokens = founder_tokens - founder_tokens_before;
         let delegate_new_tokens: Vec<u64> = delegate_stakes
             .iter()
diff --git a/pallets/subspace/tests/test_profit_share.rs b/pallets/subspace/tests/test_profit_share.rs
index 2a8cf8ab9..04cffd12d 100644
--- a/pallets/subspace/tests/test_profit_share.rs
+++ b/pallets/subspace/tests/test_profit_share.rs
@@ -83,8 +83,8 @@ fn test_add_profit_share() {
         let sum_profit_share_balances: u64 = profit_share_balances.iter().sum();
         let delta = 1000;
         assert!(
-            sum_profit_share_balances > miner_emission - delta ||
-                sum_profit_share_balances < miner_emission + delta,
+            sum_profit_share_balances > miner_emission - delta
+                || sum_profit_share_balances < miner_emission + delta,
             "profit share balances do not add up to the emission"
         );
     })
diff --git a/pallets/subspace/tests/test_registration.rs b/pallets/subspace/tests/test_registration.rs
index 112fb61cb..6d374a968 100644
--- a/pallets/subspace/tests/test_registration.rs
+++ b/pallets/subspace/tests/test_registration.rs
@@ -139,7 +139,12 @@ fn test_many_registrations() {
         SubspaceModule::set_max_registrations_per_block(n);
         for i in 0..n {
             register_module(netuid, U256::from(i), stake);
-            assert_eq!(SubspaceModule::get_subnet_n(netuid), i + 1, "Failed at i={}", i);
+            assert_eq!(
+                SubspaceModule::get_subnet_n(netuid),
+                i + 1,
+                "Failed at i={}",
+                i
+            );
         }
     });
 }
diff --git a/pallets/subspace/tests/test_staking.rs b/pallets/subspace/tests/test_staking.rs
index 1b51ad636..d28abd9b7 100644
--- a/pallets/subspace/tests/test_staking.rs
+++ b/pallets/subspace/tests/test_staking.rs
@@ -89,7 +89,10 @@ fn test_stake() {
             assert_eq!(SubspaceModule::total_stake(), total_stake);
             subnet_stake = 0;
             println!("TOTAL STAKE: {}", total_stake);
-            println!("TOTAL SUBNET STAKE: {}", SubspaceModule::get_total_subnet_stake(netuid));
+            println!(
+                "TOTAL SUBNET STAKE: {}",
+                SubspaceModule::get_total_subnet_stake(netuid)
+            );
         }
     });
 }
@@ -139,7 +142,11 @@ fn test_multiple_stake() {
             total_actual_stake, total_stake,
             "total stake should be equal to the sum of all stakes"
         );
-        assert_eq!(staker_balance, og_staker_balance - total_stake, "staker balance should be 0");
+        assert_eq!(
+            staker_balance,
+            og_staker_balance - total_stake,
+            "staker balance should be 0"
+        );
 
         // unstake from all modules
         SubspaceModule::remove_stake_multiple(
@@ -152,8 +159,14 @@ fn test_multiple_stake() {
         let total_actual_stake: u64 =
             keys.clone().into_iter().map(|k| SubspaceModule::get_stake(netuid, &k)).sum();
         let staker_balance = SubspaceModule::get_balance(&controler_key);
-        assert_eq!(total_actual_stake, 0, "total stake should be equal to the sum of all stakes");
-        assert_eq!(staker_balance, og_staker_balance, "staker balance should be 0");
+        assert_eq!(
+            total_actual_stake, 0,
+            "total stake should be equal to the sum of all stakes"
+        );
+        assert_eq!(
+            staker_balance, og_staker_balance,
+            "staker balance should be 0"
+        );
     });
 }
 
@@ -231,20 +244,38 @@ fn test_delegate_stake() {
                 SubspaceModule::add_stake(get_origin(delegate_key), netuid, *key, amount_staked);
                 uid = SubspaceModule::get_uid_for_key(netuid, key);
                 // SubspaceModule::add_stake(get_origin(*key), netuid, amount_staked);
-                assert_eq!(SubspaceModule::get_stake_for_uid(netuid, uid), amount_staked);
+                assert_eq!(
+                    SubspaceModule::get_stake_for_uid(netuid, uid),
+                    amount_staked
+                );
                 assert_eq!(SubspaceModule::get_balance(&delegate_key), 1);
-                assert_eq!(SubspaceModule::get_stake_to_vector(netuid, &delegate_key).len(), 1);
+                assert_eq!(
+                    SubspaceModule::get_stake_to_vector(netuid, &delegate_key).len(),
+                    1
+                );
                 // REMOVE STAKE
                 SubspaceModule::remove_stake(get_origin(delegate_key), netuid, *key, amount_staked);
-                assert_eq!(SubspaceModule::get_balance(&delegate_key), amount_staked + 1);
+                assert_eq!(
+                    SubspaceModule::get_balance(&delegate_key),
+                    amount_staked + 1
+                );
                 assert_eq!(SubspaceModule::get_stake_for_uid(netuid, uid), 0);
-                assert_eq!(SubspaceModule::get_stake_to_vector(netuid, &delegate_key).len(), 0);
+                assert_eq!(
+                    SubspaceModule::get_stake_to_vector(netuid, &delegate_key).len(),
+                    0
+                );
 
                 // ADD STAKE AGAIN LOL
                 SubspaceModule::add_stake(get_origin(delegate_key), netuid, *key, amount_staked);
-                assert_eq!(SubspaceModule::get_stake_for_uid(netuid, uid), amount_staked);
+                assert_eq!(
+                    SubspaceModule::get_stake_for_uid(netuid, uid),
+                    amount_staked
+                );
                 assert_eq!(SubspaceModule::get_balance(&delegate_key), 1);
-                assert_eq!(SubspaceModule::get_stake_to_vector(netuid, &delegate_key).len(), 1);
+                assert_eq!(
+                    SubspaceModule::get_stake_to_vector(netuid, &delegate_key).len(),
+                    1
+                );
 
                 // AT THE END WE SHOULD HAVE THE SAME TOTAL STAKE
                 subnet_stake += SubspaceModule::get_stake_for_uid(netuid, uid);
@@ -254,7 +285,10 @@ fn test_delegate_stake() {
             assert_eq!(SubspaceModule::total_stake(), total_stake);
             subnet_stake = 0;
             println!("TOTAL STAKE: {}", total_stake);
-            println!("TOTAL SUBNET STAKE: {}", SubspaceModule::get_total_subnet_stake(netuid));
+            println!(
+                "TOTAL SUBNET STAKE: {}",
+                SubspaceModule::get_total_subnet_stake(netuid)
+            );
         }
     });
 }
@@ -284,7 +318,10 @@ fn test_ownership_ratio() {
                 println!("DELEGATE KEY: {}", d);
                 SubspaceModule::add_stake(get_origin(*d), netuid, *k, stake_per_module);
                 let stake_from_vector = SubspaceModule::get_stake_from_vector(netuid, k);
-                assert_eq!(stake_from_vector.len(), pre_delegate_stake_from_vector.len() + i + 1);
+                assert_eq!(
+                    stake_from_vector.len(),
+                    pre_delegate_stake_from_vector.len() + i + 1
+                );
             }
             let ownership_ratios: Vec<(U256, I64F64)> =
                 SubspaceModule::get_ownership_ratios(netuid, k);
diff --git a/pallets/subspace/tests/test_step.rs b/pallets/subspace/tests/test_step.rs
index 0b5abca54..915f4fd7d 100644
--- a/pallets/subspace/tests/test_step.rs
+++ b/pallets/subspace/tests/test_step.rs
@@ -26,8 +26,8 @@ fn check_network_stats(netuid: u16) {
     println!("dividends: {:?}", dividends);
 
     assert!(
-        total_emissions >= subnet_emission - emission_buffer ||
-            total_emissions <= subnet_emission + emission_buffer
+        total_emissions >= subnet_emission - emission_buffer
+            || total_emissions <= subnet_emission + emission_buffer
     );
 }
 
@@ -139,8 +139,8 @@ fn test_dividends_same_stake() {
             let error_delta: u64 = (emissions[uid] as f64 * 0.001) as u64;
 
             assert!(
-                stake_difference < expected_stake_difference + error_delta &&
-                    stake_difference > expected_stake_difference - error_delta,
+                stake_difference < expected_stake_difference + error_delta
+                    && stake_difference > expected_stake_difference - error_delta,
                 "stake_difference: {} != expected_stake_difference: {}",
                 stake_difference,
                 expected_stake_difference
@@ -230,8 +230,8 @@ fn test_dividends_diff_stake() {
             let error_delta: u64 = (emissions[uid] as f64 * 0.001) as u64;
 
             assert!(
-                stake_difference < expected_stake_difference + error_delta &&
-                    stake_difference > expected_stake_difference - error_delta,
+                stake_difference < expected_stake_difference + error_delta
+                    && stake_difference > expected_stake_difference - error_delta,
                 "stake_difference: {} != expected_stake_difference: {}",
                 stake_difference,
                 expected_stake_difference
@@ -870,11 +870,11 @@ fn test_founder_share() {
         println!("total_dividends: {:?}", total_dividends);
         println!("total_incentives: {:?}", total_incentives);
         let expected_emission_after_founder_share = expected_emission - expected_founder_share;
-        let founder_dividend_emission = ((dividends[0] as f64 / total_dividends as f64) *
-            (expected_emission_after_founder_share / 2) as f64)
+        let founder_dividend_emission = ((dividends[0] as f64 / total_dividends as f64)
+            * (expected_emission_after_founder_share / 2) as f64)
             as u64;
-        let founder_incentive_emission = ((incentives[0] as f64 / total_incentives as f64) *
-            (expected_emission_after_founder_share / 2) as f64)
+        let founder_incentive_emission = ((incentives[0] as f64 / total_incentives as f64)
+            * (expected_emission_after_founder_share / 2) as f64)
             as u64;
         let founder_emission = founder_incentive_emission + founder_dividend_emission;
 
@@ -884,9 +884,9 @@ fn test_founder_share() {
         println!("founder_emission FAM: {:?}", founder_emission);
         let calcualted_total_emission = emissions.iter().sum::<u64>();
 
-        let calculated_founder_share = SubspaceModule::get_stake_for_key(netuid, &founder_key) -
-            founder_stake_before -
-            founder_emission;
+        let calculated_founder_share = SubspaceModule::get_stake_for_key(netuid, &founder_key)
+            - founder_stake_before
+            - founder_emission;
         let delta: u64 = 100000;
 
         println!("expected_emission: {:?}", expected_emission);
diff --git a/pallets/subspace/tests/test_subnets.rs b/pallets/subspace/tests/test_subnets.rs
index f3920b443..e91c500ab 100644
--- a/pallets/subspace/tests/test_subnets.rs
+++ b/pallets/subspace/tests/test_subnets.rs
@@ -94,8 +94,14 @@ fn test_set_single_temple(tempo: u16) {
         assert_eq!(subnet_params.tempo, tempo);
         assert_eq!(subnet_params.min_stake, min_stake);
         assert_eq!(subnet_params.max_allowed_uids, params.max_allowed_uids);
-        assert_eq!(subnet_params.min_allowed_weights, params.min_allowed_weights);
-        assert_eq!(subnet_params.max_allowed_weights, params.max_allowed_weights);
+        assert_eq!(
+            subnet_params.min_allowed_weights,
+            params.min_allowed_weights
+        );
+        assert_eq!(
+            subnet_params.max_allowed_weights,
+            params.max_allowed_weights
+        );
         assert_eq!(subnet_params.immunity_period, params.immunity_period);
         assert_eq!(subnet_params.name, params.name);
 
diff --git a/pallets/subspace/tests/test_voting.rs b/pallets/subspace/tests/test_voting.rs
index c36e691ed..652a3146a 100644
--- a/pallets/subspace/tests/test_voting.rs
+++ b/pallets/subspace/tests/test_voting.rs
@@ -18,7 +18,11 @@ fn test_subnet_porposal() {
             assert_ok!(register_module(netuid, *key, stakes[i]));
         }
         let mut params = SubspaceModule::subnet_params(netuid);
-        assert_eq!(params.vote_mode, "authority".as_bytes().to_vec(), "vote mode not set");
+        assert_eq!(
+            params.vote_mode,
+            "authority".as_bytes().to_vec(),
+            "vote mode not set"
+        );
         params.vote_mode = "stake".as_bytes().to_vec();
         println!("params: {:?}", params);
         SubspaceModule::set_subnet_params(netuid, params.clone());
@@ -27,8 +31,16 @@ fn test_subnet_porposal() {
         let final_tempo = 1000;
         params.tempo = final_tempo;
 
-        assert_eq!(params.vote_mode, "stake".as_bytes().to_vec(), "vote mode not set");
-        assert_ok!(SubspaceModule::do_add_subnet_proposal(get_origin(keys[0]), netuid, params));
+        assert_eq!(
+            params.vote_mode,
+            "stake".as_bytes().to_vec(),
+            "vote mode not set"
+        );
+        assert_ok!(SubspaceModule::do_add_subnet_proposal(
+            get_origin(keys[0]),
+            netuid,
+            params
+        ));
         // we have not passed the threshold yet
         let proposals = SubspaceModule::get_subnet_proposals(netuid);
 
@@ -70,13 +82,21 @@ fn test_max_proposals() {
         }
 
         let mut params = SubspaceModule::global_params();
-        assert_eq!(params.vote_mode, "authority".as_bytes().to_vec(), "vote mode not set");
+        assert_eq!(
+            params.vote_mode,
+            "authority".as_bytes().to_vec(),
+            "vote mode not set"
+        );
         params.vote_mode = "stake".as_bytes().to_vec();
         params.max_proposals = (n / 2) as u64;
         println!("params: {:?}", params);
         SubspaceModule::set_global_params(params.clone());
 
-        assert_eq!(params.vote_mode, "stake".as_bytes().to_vec(), "vote mode not set");
+        assert_eq!(
+            params.vote_mode,
+            "stake".as_bytes().to_vec(),
+            "vote mode not set"
+        );
         let max_proposals = SubspaceModule::get_max_proposals();
         let _modes = ["authority".as_bytes().to_vec(), "stake".as_bytes().to_vec()];
 
@@ -84,7 +104,11 @@ fn test_max_proposals() {
         subnet_params.vote_mode = "stake".as_bytes().to_vec();
         SubspaceModule::set_subnet_params(netuid, subnet_params.clone());
         subnet_params = SubspaceModule::subnet_params(netuid);
-        assert_eq!(subnet_params.vote_mode, "stake".as_bytes().to_vec(), "vote mode not set");
+        assert_eq!(
+            subnet_params.vote_mode,
+            "stake".as_bytes().to_vec(),
+            "vote mode not set"
+        );
 
         for i in 0..n {
             if i % 2 == 0 {
@@ -122,11 +146,18 @@ fn test_max_proposals() {
                 assert!(!SubspaceModule::has_max_proposals(), "proposal not added");
             }
 
-            assert!(proposals.len() as u64 <= max_proposals, "proposal not added");
+            assert!(
+                proposals.len() as u64 <= max_proposals,
+                "proposal not added"
+            );
         }
 
         assert!(SubspaceModule::has_max_proposals(), "proposal not added");
-        assert_eq!(SubspaceModule::num_proposals(), max_proposals, "proposal not added");
+        assert_eq!(
+            SubspaceModule::num_proposals(),
+            max_proposals,
+            "proposal not added"
+        );
     });
 }
 
@@ -147,7 +178,10 @@ fn test_global_porposal() {
         let max_registrations_per_block = 1000;
 
         params.max_registrations_per_block = max_registrations_per_block;
-        assert_ok!(SubspaceModule::do_add_global_proposal(get_origin(keys[0]), params));
+        assert_ok!(SubspaceModule::do_add_global_proposal(
+            get_origin(keys[0]),
+            params
+        ));
 
         // we have not passed the threshold yet
         let proposals = SubspaceModule::get_global_proposals();
@@ -186,7 +220,11 @@ fn test_unvote() {
             assert_ok!(register_module(netuid, *key, stakes[i]));
         }
         let mut params = SubspaceModule::subnet_params(netuid);
-        assert_eq!(params.vote_mode, "authority".as_bytes().to_vec(), "vote mode not set");
+        assert_eq!(
+            params.vote_mode,
+            "authority".as_bytes().to_vec(),
+            "vote mode not set"
+        );
         params.vote_mode = "stake".as_bytes().to_vec();
         println!("params: {:?}", params);
         SubspaceModule::set_subnet_params(netuid, params.clone());
@@ -195,8 +233,16 @@ fn test_unvote() {
         let final_tempo = 1000;
         params.tempo = final_tempo;
 
-        assert_eq!(params.vote_mode, "stake".as_bytes().to_vec(), "vote mode not set");
-        assert_ok!(SubspaceModule::do_add_subnet_proposal(get_origin(keys[0]), netuid, params));
+        assert_eq!(
+            params.vote_mode,
+            "stake".as_bytes().to_vec(),
+            "vote mode not set"
+        );
+        assert_ok!(SubspaceModule::do_add_subnet_proposal(
+            get_origin(keys[0]),
+            netuid,
+            params
+        ));
         assert!(SubspaceModule::proposal_exists(0));
         assert!(SubspaceModule::is_proposal_owner(&keys[0], 0));
         assert_ok!(SubspaceModule::unvote_proposal(get_origin(keys[0])));
diff --git a/pallets/subspace/tests/weights.rs b/pallets/subspace/tests/weights.rs
index bf105937c..b919f664f 100644
--- a/pallets/subspace/tests/weights.rs
+++ b/pallets/subspace/tests/weights.rs
@@ -223,7 +223,10 @@ fn test_is_self_weight_weights_length_not_one() {
         let expected = false;
         let result = SubspaceModule::is_self_weight(uid, &uids, &weights);
 
-        assert_eq!(expected, result, "Failed get expected result when `weights.len() != 1`");
+        assert_eq!(
+            expected, result,
+            "Failed get expected result when `weights.len() != 1`"
+        );
     });
 }
 
@@ -240,7 +243,10 @@ fn test_is_self_weight_uid_not_in_uids() {
         let expected = false;
         let result = SubspaceModule::is_self_weight(uid, &uids, &weights);
 
-        assert_eq!(expected, result, "Failed get expected result when `uid != uids[0]`");
+        assert_eq!(
+            expected, result,
+            "Failed get expected result when `uid != uids[0]`"
+        );
     });
 }
 
@@ -258,7 +264,10 @@ fn test_is_self_weight_uid_in_uids() {
         let expected = true;
         let result = SubspaceModule::is_self_weight(uid, &uids, &weights);
 
-        assert_eq!(expected, result, "Failed get expected result when everything _should_ be fine");
+        assert_eq!(
+            expected, result,
+            "Failed get expected result when everything _should_ be fine"
+        );
     });
 }
 
@@ -307,6 +316,9 @@ fn test_check_len_uids_within_allowed_not_within_network_pool() {
 
         let expected = false;
         let result = SubspaceModule::check_len_uids_within_allowed(netuid, &uids);
-        assert_eq!(expected, result, "Failed to detect incompatible uids for network");
+        assert_eq!(
+            expected, result,
+            "Failed to detect incompatible uids for network"
+        );
     });
 }
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 7fcbda413..091d20bc3 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -161,7 +161,10 @@ pub const DAYS: BlockNumber = HOURS * 24;
 // The version information used to identify this runtime when compiled natively.
 #[cfg(feature = "std")]
 pub fn native_version() -> NativeVersion {
-    NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
+    NativeVersion {
+        runtime_version: VERSION,
+        can_author_with: Default::default(),
+    }
 }
 
 const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
@@ -358,8 +361,10 @@ impl pallet_subspace::Config for Runtime {
 // EVM Support
 
 pub const WEIGHT_MILLISECS_PER_BLOCK: u64 = 2000;
-pub const MAXIMUM_BLOCK_WEIGHT: Weight =
-    Weight::from_parts(WEIGHT_MILLISECS_PER_BLOCK * WEIGHT_REF_TIME_PER_MILLIS, u64::MAX);
+pub const MAXIMUM_BLOCK_WEIGHT: Weight = Weight::from_parts(
+    WEIGHT_MILLISECS_PER_BLOCK * WEIGHT_REF_TIME_PER_MILLIS,
+    u64::MAX,
+);
 pub const MAXIMUM_BLOCK_LENGTH: u32 = 5 * 1024 * 1024;
 
 impl pallet_evm_chain_id::Config for Runtime {}
@@ -567,8 +572,9 @@ impl fp_self_contained::SelfContainedCall for RuntimeCall {
         len: usize,
     ) -> Option<Result<(), TransactionValidityError>> {
         match self {
-            RuntimeCall::Ethereum(call) =>
-                call.pre_dispatch_self_contained(info, dispatch_info, len),
+            RuntimeCall::Ethereum(call) => {
+                call.pre_dispatch_self_contained(info, dispatch_info, len)
+            }
             _ => None,
         }
     }
@@ -578,10 +584,11 @@ impl fp_self_contained::SelfContainedCall for RuntimeCall {
         info: Self::SignedInfo,
     ) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {
         match self {
-            call @ RuntimeCall::Ethereum(pallet_ethereum::Call::transact { .. }) =>
+            call @ RuntimeCall::Ethereum(pallet_ethereum::Call::transact { .. }) => {
                 Some(call.dispatch(RuntimeOrigin::from(
                     pallet_ethereum::RawOrigin::EthereumTransaction(info),
-                ))),
+                )))
+            }
             _ => None,
         }
     }
diff --git a/rustfmt.toml b/rustfmt.toml
index 7de0d3fd3..143260cb4 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1,9 +1,7 @@
 # Basic
 max_width = 100
-use_small_heuristics = "Max"
 # Imports
 imports_granularity = "Crate"
-reorder_imports = true
 # Consistency
 newline_style = "Unix"
 # Format comments
@@ -11,12 +9,4 @@ comment_width = 100
 wrap_comments = true
 # Misc
 chain_width = 80
-spaces_around_ranges = false
-binop_separator = "Back"
-reorder_impl_items = false
-match_arm_leading_pipes = "Preserve"
-match_arm_blocks = false
-match_block_trailing_comma = true
-trailing_comma = "Vertical"
-trailing_semicolon = false
 use_field_init_shorthand = true
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index a010411e4..249eb221e 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -20,13 +20,13 @@ fn localnet_run(mut r: flags::Run) {
                 r.bootnodes.push(BOB_NODE.bootnode_uri(Ipv4Addr::LOCALHOST.into()));
             }
             (ALICE_NODE.clone(), ALICE_ACCOUNT.clone())
-        },
+        }
         (false, true) => {
             if r.bootnodes.is_empty() {
                 r.bootnodes.push(ALICE_NODE.bootnode_uri(Ipv4Addr::LOCALHOST.into()));
             }
             (BOB_NODE.clone(), BOB_ACCOUNT.clone())
-        },
+        }
         (false, false) => (Node::default(), Account::default()),
         _ => panic!("select only one of: --alice, --bob"),
     };
@@ -58,7 +58,7 @@ fn localnet_run(mut r: flags::Run) {
     match (path.exists(), path.is_dir()) {
         (true, false) => panic!("provided path must be a directory"),
         (false, false) => std::fs::create_dir(&path).unwrap(),
-        _ => {},
+        _ => {}
     }
 
     let chain_path = r
@@ -118,8 +118,12 @@ struct Account<'a> {
 
 static ALICE_NODE: Node<'static> = Node {
     name: Some(Cow::Borrowed("Alice")),
-    id: Some(Cow::Borrowed("12D3KooWBorpca6RKiebVjeFJA5o9iVWnZpg98yQbYqRC6f8CnLw")),
-    key: Some(Cow::Borrowed("2756181a3b9bca683a35b51a0a5d75ee536738680bcb9066c68be1db305a1ac5")),
+    id: Some(Cow::Borrowed(
+        "12D3KooWBorpca6RKiebVjeFJA5o9iVWnZpg98yQbYqRC6f8CnLw",
+    )),
+    key: Some(Cow::Borrowed(
+        "2756181a3b9bca683a35b51a0a5d75ee536738680bcb9066c68be1db305a1ac5",
+    )),
     tcp_port: 30341,
     rpc_port: 9951,
     validator: true,
@@ -134,8 +138,12 @@ static ALICE_ACCOUNT: Account<'static> = Account {
 
 static BOB_NODE: Node<'static> = Node {
     name: Some(Cow::Borrowed("Bob")),
-    id: Some(Cow::Borrowed("12D3KooWQh3CeSp2rpUVvPb6jqvmHVCUieoZmKbkUhZ8rPR77vmA")),
-    key: Some(Cow::Borrowed("e83fa0787cb280d95c666ead866a2a4bc1ee1e36faa1ed06623595eb3f474681")),
+    id: Some(Cow::Borrowed(
+        "12D3KooWQh3CeSp2rpUVvPb6jqvmHVCUieoZmKbkUhZ8rPR77vmA",
+    )),
+    key: Some(Cow::Borrowed(
+        "e83fa0787cb280d95c666ead866a2a4bc1ee1e36faa1ed06623595eb3f474681",
+    )),
     tcp_port: 30342,
     rpc_port: 9952,
     validator: true,