diff --git a/benches/benches/benchmarks/always_success.rs b/benches/benches/benchmarks/always_success.rs
index 33ed8bda8e..677aed92c9 100644
--- a/benches/benches/benchmarks/always_success.rs
+++ b/benches/benches/benchmarks/always_success.rs
@@ -1,7 +1,7 @@
 use crate::benchmarks::util::{gen_always_success_block, new_always_success_chain};
 use ckb_store::{self, ChainStore};
 use ckb_verification_traits::Switch;
-use criterion::{criterion_group, BatchSize, BenchmarkId, Criterion};
+use criterion::{BatchSize, BenchmarkId, Criterion, criterion_group};
 use std::sync::Arc;
 
 #[cfg(not(feature = "ci"))]
@@ -24,10 +24,12 @@ fn bench(c: &mut Criterion) {
                         let chains = new_always_success_chain(*i, 2);
                         let (ref chain1, ref shared1) = chains.0[0];
                         let (ref chain2, ref shared2) = chains.0[1];
-                        let mut blocks = vec![shared1
-                            .snapshot()
-                            .get_block(&shared1.genesis_hash())
-                            .unwrap()];
+                        let mut blocks = vec![
+                            shared1
+                                .snapshot()
+                                .get_block(&shared1.genesis_hash())
+                                .unwrap(),
+                        ];
                         let mut parent = blocks[0].clone();
                         (0..20).for_each(|_| {
                             let block = gen_always_success_block(&mut blocks, &parent, shared2);
@@ -72,10 +74,12 @@ fn bench(c: &mut Criterion) {
                         let (ref chain1, ref shared1) = chains.0[0];
                         let (ref chain2, ref shared2) = chains.0[1];
                         let (ref chain3, ref shared3) = chains.0[2];
-                        let mut blocks = vec![shared1
-                            .snapshot()
-                            .get_block(&shared1.genesis_hash())
-                            .unwrap()];
+                        let mut blocks = vec![
+                            shared1
+                                .snapshot()
+                                .get_block(&shared1.genesis_hash())
+                                .unwrap(),
+                        ];
                         let mut parent = blocks[0].clone();
                         (0..5).for_each(|i| {
                             let block = gen_always_success_block(&mut blocks, &parent, shared2);
@@ -149,10 +153,12 @@ fn bench(c: &mut Criterion) {
                         let (ref chain1, ref shared1) = chains.0[0];
                         let (ref chain2, ref shared2) = chains.0[1];
                         let (ref chain3, ref shared3) = chains.0[2];
-                        let mut blocks = vec![shared1
-                            .snapshot()
-                            .get_block(&shared1.genesis_hash())
-                            .unwrap()];
+                        let mut blocks = vec![
+                            shared1
+                                .snapshot()
+                                .get_block(&shared1.genesis_hash())
+                                .unwrap(),
+                        ];
                         let mut parent = blocks[0].clone();
                         (0..5).for_each(|i| {
                             let block = gen_always_success_block(&mut blocks, &parent, shared2);
diff --git a/benches/benches/benchmarks/overall.rs b/benches/benches/benchmarks/overall.rs
index 17b8c91ce8..46596def61 100644
--- a/benches/benches/benchmarks/overall.rs
+++ b/benches/benches/benchmarks/overall.rs
@@ -1,28 +1,28 @@
 use crate::benchmarks::util::{create_2out_transaction, create_secp_tx, secp_cell};
 use ckb_app_config::NetworkConfig;
 use ckb_app_config::{BlockAssemblerConfig, TxPoolConfig};
-use ckb_chain::{start_chain_services, ChainController};
+use ckb_chain::{ChainController, start_chain_services};
 use ckb_chain_spec::consensus::{ConsensusBuilder, ProposalWindow};
 use ckb_dao_utils::genesis_dao_data;
 use ckb_jsonrpc_types::JsonBytes;
-use ckb_network::{network::TransportType, Flags, NetworkController, NetworkService, NetworkState};
+use ckb_network::{Flags, NetworkController, NetworkService, NetworkState, network::TransportType};
 use ckb_shared::{Shared, SharedBuilder};
 use ckb_store::ChainStore;
 use ckb_types::{
+    U256,
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, BlockView, Capacity, EpochNumberWithFraction, FeeRate,
-        ScriptHashType, TransactionBuilder, TransactionView,
+        BlockBuilder, BlockView, Capacity, EpochNumberWithFraction, FeeRate, ScriptHashType,
+        TransactionBuilder, TransactionView, capacity_bytes,
     },
     packed::{Block, CellDep, CellInput, CellOutput, Header, OutPoint},
     prelude::*,
     utilities::difficulty_to_compact,
-    U256,
 };
 use ckb_verification::HeaderVerifier;
 use ckb_verification_traits::Switch;
 use ckb_verification_traits::Verifier;
-use criterion::{criterion_group, BatchSize, BenchmarkId, Criterion};
+use criterion::{BatchSize, BenchmarkId, Criterion, criterion_group};
 use rand::random;
 use std::sync::Arc;
 
diff --git a/benches/benches/benchmarks/resolve.rs b/benches/benches/benchmarks/resolve.rs
index 37ec9d11c3..14bd16c8aa 100644
--- a/benches/benches/benchmarks/resolve.rs
+++ b/benches/benches/benchmarks/resolve.rs
@@ -1,24 +1,23 @@
 use crate::benchmarks::util::create_2out_transaction;
 use ckb_app_config::{BlockAssemblerConfig, TxPoolConfig};
-use ckb_chain::{start_chain_services, ChainController};
+use ckb_chain::{ChainController, start_chain_services};
 use ckb_chain_spec::{ChainSpec, IssuedCell};
 use ckb_jsonrpc_types::JsonBytes;
 use ckb_resource::Resource;
 use ckb_shared::{Shared, SharedBuilder, Snapshot};
 use ckb_types::global::DATA_DIR;
 use ckb_types::{
+    H160, H256,
     bytes::Bytes,
     core::{
-        capacity_bytes,
+        BlockView, Capacity, DepType, FeeRate, ScriptHashType, TransactionView, capacity_bytes,
         cell::{resolve_transaction, setup_system_cell_cache},
-        BlockView, Capacity, DepType, FeeRate, ScriptHashType, TransactionView,
     },
     h160, h256,
     packed::{CellDep, OutPoint, Script},
     prelude::*,
-    H160, H256,
 };
-use criterion::{criterion_group, BatchSize, BenchmarkId, Criterion};
+use criterion::{BatchSize, BenchmarkId, Criterion, criterion_group};
 use std::collections::HashSet;
 
 #[cfg(not(feature = "ci"))]
diff --git a/benches/benches/benchmarks/secp_2in2out.rs b/benches/benches/benchmarks/secp_2in2out.rs
index 03ebab1685..79ec143da2 100644
--- a/benches/benches/benchmarks/secp_2in2out.rs
+++ b/benches/benches/benchmarks/secp_2in2out.rs
@@ -1,7 +1,7 @@
 use crate::benchmarks::util::{gen_secp_block, new_secp_chain};
 use ckb_store::{self, ChainStore};
 use ckb_verification_traits::Switch;
-use criterion::{criterion_group, BatchSize, BenchmarkId, Criterion};
+use criterion::{BatchSize, BenchmarkId, Criterion, criterion_group};
 use std::sync::Arc;
 
 #[cfg(not(feature = "ci"))]
@@ -24,10 +24,12 @@ fn bench(c: &mut Criterion) {
                         let chains = new_secp_chain(*txs_size, 2);
                         let (ref chain1, ref shared1) = chains.0[0];
                         let (ref chain2, ref shared2) = chains.0[1];
-                        let mut blocks = vec![shared1
-                            .snapshot()
-                            .get_block(&shared1.genesis_hash())
-                            .unwrap()];
+                        let mut blocks = vec![
+                            shared1
+                                .snapshot()
+                                .get_block(&shared1.genesis_hash())
+                                .unwrap(),
+                        ];
                         let mut parent = blocks[0].clone();
                         (0..20).for_each(|_| {
                             let block = gen_secp_block(&mut blocks, &parent, shared2);
@@ -72,10 +74,12 @@ fn bench(c: &mut Criterion) {
                         let (ref chain1, ref shared1) = chains.0[0];
                         let (ref chain2, ref shared2) = chains.0[1];
                         let (ref chain3, ref shared3) = chains.0[2];
-                        let mut blocks = vec![shared1
-                            .snapshot()
-                            .get_block(&shared1.genesis_hash())
-                            .unwrap()];
+                        let mut blocks = vec![
+                            shared1
+                                .snapshot()
+                                .get_block(&shared1.genesis_hash())
+                                .unwrap(),
+                        ];
                         let mut parent = blocks[0].clone();
                         (0..5).for_each(|i| {
                             let block = gen_secp_block(&mut blocks, &parent, shared2);
@@ -149,10 +153,12 @@ fn bench(c: &mut Criterion) {
                         let (ref chain1, ref shared1) = chains.0[0];
                         let (ref chain2, ref shared2) = chains.0[1];
                         let (ref chain3, ref shared3) = chains.0[2];
-                        let mut blocks = vec![shared1
-                            .snapshot()
-                            .get_block(&shared1.genesis_hash())
-                            .unwrap()];
+                        let mut blocks = vec![
+                            shared1
+                                .snapshot()
+                                .get_block(&shared1.genesis_hash())
+                                .unwrap(),
+                        ];
                         let mut parent = blocks[0].clone();
                         (0..5).for_each(|i| {
                             let block = gen_secp_block(&mut blocks, &parent, shared2);
diff --git a/benches/benches/benchmarks/util.rs b/benches/benches/benchmarks/util.rs
index ac43d170ae..99e7dfd556 100644
--- a/benches/benches/benchmarks/util.rs
+++ b/benches/benches/benchmarks/util.rs
@@ -1,4 +1,4 @@
-use ckb_chain::{start_chain_services, ChainController};
+use ckb_chain::{ChainController, start_chain_services};
 use ckb_chain_spec::consensus::{ConsensusBuilder, ProposalWindow};
 use ckb_crypto::secp::Privkey;
 use ckb_dao::DaoCalculator;
@@ -8,12 +8,12 @@ use ckb_store::ChainStore;
 use ckb_system_scripts::BUNDLED_CELL;
 use ckb_test_chain_utils::always_success_cell;
 use ckb_types::{
+    H160, H256, U256,
     bytes::Bytes,
     core::{
-        capacity_bytes,
-        cell::{resolve_transaction, OverlayCellProvider, TransactionsProvider},
         BlockBuilder, BlockView, Capacity, EpochNumberWithFraction, HeaderView, ScriptHashType,
-        TransactionBuilder, TransactionView,
+        TransactionBuilder, TransactionView, capacity_bytes,
+        cell::{OverlayCellProvider, TransactionsProvider, resolve_transaction},
     },
     h160, h256,
     packed::{
@@ -21,7 +21,6 @@ use ckb_types::{
     },
     prelude::*,
     utilities::difficulty_to_compact,
-    H160, H256, U256,
 };
 use rand::random;
 use std::collections::HashSet;
diff --git a/block-filter/src/filter.rs b/block-filter/src/filter.rs
index 65fd9fca40..271f36532e 100644
--- a/block-filter/src/filter.rs
+++ b/block-filter/src/filter.rs
@@ -1,13 +1,13 @@
 use ckb_async_runtime::tokio::{self, task::block_in_place};
 use ckb_logger::{debug, info, warn};
 use ckb_shared::Shared;
-use ckb_stop_handler::{new_tokio_exit_rx, CancellationToken};
+use ckb_stop_handler::{CancellationToken, new_tokio_exit_rx};
 use ckb_store::{ChainDB, ChainStore};
 use ckb_types::{
     core::HeaderView,
     packed::{Byte32, CellOutput, OutPoint},
     prelude::*,
-    utilities::{build_filter_data, FilterDataProvider},
+    utilities::{FilterDataProvider, build_filter_data},
 };
 
 const NAME: &str = "BlockFilter";
@@ -163,6 +163,12 @@ impl BlockFilter {
             )
             .expect("insert_block_filter should be ok");
         db_transaction.commit().expect("commit should be ok");
-        debug!("Inserted filter data for block: {}, hash: {:#x}, filter data size: {}, transactions size: {}", header.number(), header.hash(), filter_data.len(), transactions_size);
+        debug!(
+            "Inserted filter data for block: {}, hash: {:#x}, filter data size: {}, transactions size: {}",
+            header.number(),
+            header.hash(),
+            filter_data.len(),
+            transactions_size
+        );
     }
 }
diff --git a/chain/src/chain_controller.rs b/chain/src/chain_controller.rs
index 94bd3b99fe..88d40a5775 100644
--- a/chain/src/chain_controller.rs
+++ b/chain/src/chain_controller.rs
@@ -9,12 +9,12 @@ use ckb_error::{Error, InternalErrorKind};
 use ckb_logger::{self, error};
 use ckb_store::ChainDB;
 use ckb_types::{
-    core::{service::Request, BlockView},
+    core::{BlockView, service::Request},
     packed::Byte32,
 };
 use ckb_verification_traits::Switch;
-use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 
 /// Controller to the chain service.
 ///
diff --git a/chain/src/chain_service.rs b/chain/src/chain_service.rs
index a1b3a05e2a..82d1dd6117 100644
--- a/chain/src/chain_service.rs
+++ b/chain/src/chain_service.rs
@@ -3,13 +3,13 @@
 
 use crate::orphan_broker::OrphanBroker;
 use crate::{LonelyBlock, ProcessBlockRequest};
-use ckb_channel::{select, Receiver};
+use ckb_channel::{Receiver, select};
 use ckb_error::{Error, InternalErrorKind};
 use ckb_logger::{self, debug, error, info, warn};
 use ckb_shared::block_status::BlockStatus;
 use ckb_shared::shared::Shared;
 use ckb_stop_handler::new_crossbeam_exit_rx;
-use ckb_types::core::{service::Request, BlockView};
+use ckb_types::core::{BlockView, service::Request};
 use ckb_verification::{BlockVerifier, NonContextualBlockTxsVerifier};
 use ckb_verification_traits::Verifier;
 
diff --git a/chain/src/init.rs b/chain/src/init.rs
index e352ed43ab..5e0d90efd3 100644
--- a/chain/src/init.rs
+++ b/chain/src/init.rs
@@ -7,7 +7,7 @@ use crate::orphan_broker::OrphanBroker;
 use crate::preload_unverified_blocks_channel::PreloadUnverifiedBlocksChannel;
 use crate::utils::orphan_block_pool::OrphanBlockPool;
 use crate::verify::ConsumeUnverifiedBlocks;
-use crate::{chain_controller::ChainController, LonelyBlockHash, UnverifiedBlock};
+use crate::{LonelyBlockHash, UnverifiedBlock, chain_controller::ChainController};
 use ckb_channel::{self as channel, SendError};
 use ckb_constant::sync::BLOCK_DOWNLOAD_WINDOW;
 use ckb_logger::warn;
@@ -15,8 +15,8 @@ use ckb_shared::ChainServicesBuilder;
 use ckb_stop_handler::register_thread;
 use ckb_types::packed::Byte32;
 use dashmap::DashSet;
-use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 use std::thread;
 
 const ORPHAN_BLOCK_SIZE: usize = BLOCK_DOWNLOAD_WINDOW as usize;
diff --git a/chain/src/init_load_unverified.rs b/chain/src/init_load_unverified.rs
index 30b0247cdb..4c958c08b0 100644
--- a/chain/src/init_load_unverified.rs
+++ b/chain/src/init_load_unverified.rs
@@ -11,8 +11,8 @@ use ckb_types::core::{BlockNumber, BlockView};
 use ckb_types::packed;
 use ckb_types::prelude::{Entity, FromSliceShouldBeOk, Pack, Reader};
 use std::cmp;
-use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 
 pub(crate) struct InitLoadUnverified {
     shared: Shared,
diff --git a/chain/src/orphan_broker.rs b/chain/src/orphan_broker.rs
index 6becc7824d..4903e2beca 100644
--- a/chain/src/orphan_broker.rs
+++ b/chain/src/orphan_broker.rs
@@ -1,15 +1,15 @@
 #![allow(missing_docs)]
 
 use crate::utils::orphan_block_pool::{OrphanBlockPool, ParentHash};
-use crate::{delete_unverified_block, LonelyBlockHash, VerifyResult};
+use crate::{LonelyBlockHash, VerifyResult, delete_unverified_block};
 use ckb_channel::Sender;
 use ckb_error::InternalErrorKind;
 use ckb_logger::internal::trace;
 use ckb_logger::{debug, error, info};
-use ckb_shared::block_status::BlockStatus;
 use ckb_shared::Shared;
+use ckb_shared::block_status::BlockStatus;
 use ckb_store::ChainStore;
-use ckb_types::{packed::Byte32, U256};
+use ckb_types::{U256, packed::Byte32};
 use dashmap::DashSet;
 use std::sync::Arc;
 
@@ -53,9 +53,7 @@ impl OrphanBroker {
         if !leader_is_pending_verify && !leader_status.contains(BlockStatus::BLOCK_STORED) {
             trace!(
                 "orphan leader: {} not stored {:?} and not in is_pending_verify: {}",
-                leader_hash,
-                leader_status,
-                leader_is_pending_verify
+                leader_hash, leader_status, leader_is_pending_verify
             );
             return;
         }
@@ -115,11 +113,7 @@ impl OrphanBroker {
         if parent_is_pending_verify || parent_status.contains(BlockStatus::BLOCK_STORED) {
             debug!(
                 "parent {} has stored: {:?} or is_pending_verify: {}, processing descendant directly {}-{}",
-                parent_hash,
-                parent_status,
-                parent_is_pending_verify,
-                block_number,
-                block_hash,
+                parent_hash, parent_status, parent_is_pending_verify, block_number, block_hash,
             );
             self.process_descendant(lonely_block);
         } else if parent_status.eq(&BlockStatus::BLOCK_INVALID) {
diff --git a/chain/src/tests/basic.rs b/chain/src/tests/basic.rs
index b1d2947a82..fefd63154a 100644
--- a/chain/src/tests/basic.rs
+++ b/chain/src/tests/basic.rs
@@ -1,26 +1,27 @@
-use crate::tests::util::start_chain;
 use crate::ChainController;
+use crate::tests::util::start_chain;
 use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_dao_utils::genesis_dao_data;
 use ckb_error::assert_error_eq;
 use ckb_shared::shared::Shared;
 use ckb_store::ChainStore;
 use ckb_test_chain_utils::{
-    create_always_success_tx, create_cellbase, create_multi_outputs_transaction,
-    create_transaction, create_transaction_with_out_point, dao_data, MockChain, MockStore,
+    MockChain, MockStore, create_always_success_tx, create_cellbase,
+    create_multi_outputs_transaction, create_transaction, create_transaction_with_out_point,
+    dao_data,
 };
 use ckb_types::core::error::OutPointError;
 use ckb_types::prelude::*;
 use ckb_types::{
+    U256,
     bytes::Bytes,
     core::{
+        BlockBuilder, BlockView, Capacity, HeaderView, TransactionBuilder, TransactionInfo,
         capacity_bytes,
         cell::{CellMeta, CellProvider, CellStatus},
-        BlockBuilder, BlockView, Capacity, HeaderView, TransactionBuilder, TransactionInfo,
     },
     packed::{CellInput, CellOutputBuilder, OutPoint, Script},
     utilities::{compact_to_difficulty, difficulty_to_compact},
-    U256,
 };
 use ckb_verification_traits::Switch;
 use std::sync::Arc;
@@ -33,9 +34,11 @@ fn repeat_process_block() {
     chain.gen_empty_block_with_nonce(100u128, &mock_store);
     let block = Arc::new(chain.blocks().last().unwrap().clone());
 
-    assert!(chain_controller
-        .blocking_process_block_with_switch(Arc::clone(&block), Switch::DISABLE_EXTENSION)
-        .expect("process block ok"));
+    assert!(
+        chain_controller
+            .blocking_process_block_with_switch(Arc::clone(&block), Switch::DISABLE_EXTENSION)
+            .expect("process block ok")
+    );
     assert_eq!(
         shared
             .store()
@@ -45,9 +48,11 @@ fn repeat_process_block() {
         Some(true)
     );
 
-    assert!(!chain_controller
-        .blocking_process_block_with_switch(Arc::clone(&block), Switch::DISABLE_EXTENSION)
-        .expect("process block ok"));
+    assert!(
+        !chain_controller
+            .blocking_process_block_with_switch(Arc::clone(&block), Switch::DISABLE_EXTENSION)
+            .expect("process block ok")
+    );
     assert_eq!(
         shared
             .store()
@@ -160,9 +165,11 @@ fn test_genesis_transaction_spend() {
     }
 
     for block in &chain.blocks()[0..10] {
-        assert!(chain_controller
-            .blocking_process_block_with_switch(Arc::new(block.clone()), Switch::DISABLE_ALL)
-            .is_ok());
+        assert!(
+            chain_controller
+                .blocking_process_block_with_switch(Arc::new(block.clone()), Switch::DISABLE_ALL)
+                .is_ok()
+        );
     }
 
     assert_eq!(
diff --git a/chain/src/tests/block_assembler.rs b/chain/src/tests/block_assembler.rs
index 6e8a71e516..4c9d324b14 100644
--- a/chain/src/tests/block_assembler.rs
+++ b/chain/src/tests/block_assembler.rs
@@ -1,12 +1,12 @@
 use crate::tests::util::dummy_network;
-use crate::{start_chain_services, ChainController};
+use crate::{ChainController, start_chain_services};
 use ckb_app_config::BlockAssemblerConfig;
 use ckb_chain_spec::consensus::Consensus;
 use ckb_dao_utils::genesis_dao_data;
 use ckb_jsonrpc_types::ScriptHashType;
 use ckb_shared::{ChainServicesBuilder, Shared, SharedBuilder, Snapshot};
 use ckb_store::ChainStore;
-use ckb_tx_pool::{block_assembler::CandidateUncles, PlugTarget, TxEntry};
+use ckb_tx_pool::{PlugTarget, TxEntry, block_assembler::CandidateUncles};
 use ckb_types::{
     bytes::Bytes,
     core::{
diff --git a/chain/src/tests/cell.rs b/chain/src/tests/cell.rs
index 3d9c2fd5b9..92983796af 100644
--- a/chain/src/tests/cell.rs
+++ b/chain/src/tests/cell.rs
@@ -2,18 +2,17 @@ use crate::tests::util::start_chain;
 use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_dao_utils::genesis_dao_data;
 use ckb_shared::shared::Shared;
-use ckb_store::{attach_block_cell, detach_block_cell, ChainStore};
+use ckb_store::{ChainStore, attach_block_cell, detach_block_cell};
 use ckb_test_chain_utils::{
-    always_success_cell, calculate_reward, create_always_success_tx, MockStore,
+    MockStore, always_success_cell, calculate_reward, create_always_success_tx,
 };
 use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes,
-        cell::{CellProvider, CellStatus},
         BlockBuilder, BlockView, Capacity, EpochNumberWithFraction, HeaderView, TransactionBuilder,
-        TransactionView,
+        TransactionView, capacity_bytes,
+        cell::{CellProvider, CellStatus},
     },
     packed::{CellInput, CellOutputBuilder, OutPoint},
     utilities::DIFF_TWO,
@@ -171,7 +170,9 @@ fn test_block_cells_update() {
     }
 
     // ensure issue_tx outputs is back to live after detach_block_cell
-    assert!(txn_cell_provider
-        .cell(&issue_tx.output_pts()[0], false)
-        .is_live());
+    assert!(
+        txn_cell_provider
+            .cell(&issue_tx.output_pts()[0], false)
+            .is_live()
+    );
 }
diff --git a/chain/src/tests/delay_verify.rs b/chain/src/tests/delay_verify.rs
index bd36fa558f..3b416ba55d 100644
--- a/chain/src/tests/delay_verify.rs
+++ b/chain/src/tests/delay_verify.rs
@@ -2,8 +2,8 @@ use crate::tests::util::start_chain;
 use ckb_error::assert_error_eq;
 use ckb_store::ChainStore;
 use ckb_test_chain_utils::{
-    create_cellbase, create_multi_outputs_transaction, create_transaction,
-    create_transaction_with_out_point, dao_data, MockChain, MockStore,
+    MockChain, MockStore, create_cellbase, create_multi_outputs_transaction, create_transaction,
+    create_transaction_with_out_point, dao_data,
 };
 use ckb_types::core::error::OutPointError;
 use ckb_types::prelude::*;
diff --git a/chain/src/tests/dep_cell.rs b/chain/src/tests/dep_cell.rs
index 64e3fbe7d4..fa417a52ff 100644
--- a/chain/src/tests/dep_cell.rs
+++ b/chain/src/tests/dep_cell.rs
@@ -8,8 +8,8 @@ use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, TransactionBuilder,
-        TransactionView,
+        BlockBuilder, Capacity, EpochNumberWithFraction, TransactionBuilder, TransactionView,
+        capacity_bytes,
     },
     packed::{Block, CellDep, CellInput, CellOutput, CellOutputBuilder, OutPoint},
     utilities::DIFF_TWO,
diff --git a/chain/src/tests/find_fork.rs b/chain/src/tests/find_fork.rs
index 2c39cfd0ca..48a9cefc36 100644
--- a/chain/src/tests/find_fork.rs
+++ b/chain/src/tests/find_fork.rs
@@ -1,6 +1,6 @@
 use crate::utils::forkchanges::ForkChanges;
 use crate::verify::ConsumeUnverifiedBlockProcessor;
-use crate::{start_chain_services, UnverifiedBlock};
+use crate::{UnverifiedBlock, start_chain_services};
 use ckb_chain_spec::consensus::{Consensus, ProposalWindow};
 use ckb_proposal_table::ProposalTable;
 use ckb_shared::SharedBuilder;
@@ -8,10 +8,10 @@ use ckb_store::ChainStore;
 use ckb_systemtime::unix_time_as_millis;
 use ckb_test_chain_utils::{MockChain, MockStore};
 use ckb_types::{
+    U256,
     core::{BlockBuilder, BlockExt, BlockView},
     packed,
     prelude::Pack,
-    U256,
 };
 use ckb_verification_traits::Switch;
 use dashmap::DashSet;
diff --git a/chain/src/tests/load_code_with_snapshot.rs b/chain/src/tests/load_code_with_snapshot.rs
index 15f9f2f594..3469cbebeb 100644
--- a/chain/src/tests/load_code_with_snapshot.rs
+++ b/chain/src/tests/load_code_with_snapshot.rs
@@ -9,10 +9,9 @@ use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes,
-        hardfork::{HardForks, CKB2021, CKB2023},
         BlockBuilder, Capacity, EpochNumberWithFraction, ScriptHashType, TransactionBuilder,
-        TransactionView,
+        TransactionView, capacity_bytes,
+        hardfork::{CKB2021, CKB2023, HardForks},
     },
     packed::{self, CellDep, CellInput, CellOutputBuilder, OutPoint, Script},
     utilities::DIFF_TWO,
diff --git a/chain/src/tests/load_input_cell_data.rs b/chain/src/tests/load_input_cell_data.rs
index 236a952325..c84f881da5 100644
--- a/chain/src/tests/load_input_cell_data.rs
+++ b/chain/src/tests/load_input_cell_data.rs
@@ -9,8 +9,8 @@ use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, TransactionBuilder,
-        TransactionView,
+        BlockBuilder, Capacity, EpochNumberWithFraction, TransactionBuilder, TransactionView,
+        capacity_bytes,
     },
     packed::{CellDep, CellInput, CellOutputBuilder, OutPoint},
     utilities::DIFF_TWO,
diff --git a/chain/src/tests/load_input_data_hash_cell.rs b/chain/src/tests/load_input_data_hash_cell.rs
index b753c1d91f..0aff79f5bd 100644
--- a/chain/src/tests/load_input_data_hash_cell.rs
+++ b/chain/src/tests/load_input_data_hash_cell.rs
@@ -9,8 +9,8 @@ use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, TransactionBuilder,
-        TransactionView,
+        BlockBuilder, Capacity, EpochNumberWithFraction, TransactionBuilder, TransactionView,
+        capacity_bytes,
     },
     packed::{CellDep, CellInput, CellOutputBuilder, OutPoint},
     utilities::DIFF_TWO,
diff --git a/chain/src/tests/non_contextual_block_txs_verify.rs b/chain/src/tests/non_contextual_block_txs_verify.rs
index 68178658d8..8eccb6c836 100644
--- a/chain/src/tests/non_contextual_block_txs_verify.rs
+++ b/chain/src/tests/non_contextual_block_txs_verify.rs
@@ -3,8 +3,8 @@ use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_dao_utils::genesis_dao_data;
 use ckb_shared::shared::Shared;
 use ckb_store::ChainStore;
-use ckb_test_chain_utils::always_success_cell;
 use ckb_test_chain_utils::MockStore;
+use ckb_test_chain_utils::always_success_cell;
 use ckb_test_chain_utils::{
     calculate_reward, create_always_success_out_point, create_always_success_tx,
 };
@@ -12,8 +12,8 @@ use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, BlockView, Capacity, EpochNumberWithFraction, HeaderView,
-        TransactionBuilder, TransactionView,
+        BlockBuilder, BlockView, Capacity, EpochNumberWithFraction, HeaderView, TransactionBuilder,
+        TransactionView, capacity_bytes,
     },
     packed::{CellDep, CellInput, CellOutputBuilder, OutPoint},
     utilities::DIFF_TWO,
diff --git a/chain/src/tests/reward.rs b/chain/src/tests/reward.rs
index 876a1495bf..078f080d82 100644
--- a/chain/src/tests/reward.rs
+++ b/chain/src/tests/reward.rs
@@ -5,15 +5,15 @@ use ckb_reward_calculator::RewardCalculator;
 use ckb_shared::shared::Shared;
 use ckb_store::ChainStore;
 use ckb_test_chain_utils::{
-    always_success_cell, calculate_reward, create_always_success_out_point,
-    create_always_success_tx, dao_data, MockStore,
+    MockStore, always_success_cell, calculate_reward, create_always_success_out_point,
+    create_always_success_tx, dao_data,
 };
 use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, BlockView, Capacity, EpochNumberWithFraction, HeaderView,
-        ScriptHashType, TransactionBuilder, TransactionView, UncleBlockView,
+        BlockBuilder, BlockView, Capacity, EpochNumberWithFraction, HeaderView, ScriptHashType,
+        TransactionBuilder, TransactionView, UncleBlockView, capacity_bytes,
     },
     packed::{
         self, CellDep, CellInput, CellOutputBuilder, OutPoint, ProposalShortId, Script,
diff --git a/chain/src/tests/util.rs b/chain/src/tests/util.rs
index 2d1cde059f..4583b7f8a3 100644
--- a/chain/src/tests/util.rs
+++ b/chain/src/tests/util.rs
@@ -1,10 +1,10 @@
-use crate::{start_chain_services, ChainController};
+use crate::{ChainController, start_chain_services};
 use ckb_app_config::TxPoolConfig;
 use ckb_app_config::{BlockAssemblerConfig, NetworkConfig};
 use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_dao_utils::genesis_dao_data;
 use ckb_jsonrpc_types::ScriptHashType;
-use ckb_network::{network::TransportType, Flags, NetworkController, NetworkService, NetworkState};
+use ckb_network::{Flags, NetworkController, NetworkService, NetworkState, network::TransportType};
 use ckb_shared::{Shared, SharedBuilder};
 use ckb_store::ChainStore;
 use ckb_test_chain_utils::{always_success_cell, create_always_success_tx};
@@ -12,8 +12,8 @@ use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, HeaderView,
-        TransactionBuilder, TransactionView,
+        BlockBuilder, Capacity, EpochNumberWithFraction, HeaderView, TransactionBuilder,
+        TransactionView, capacity_bytes,
     },
     h256,
     packed::{CellInput, CellOutput, OutPoint},
diff --git a/chain/src/verify.rs b/chain/src/verify.rs
index 56a9aeace6..b34c8df008 100644
--- a/chain/src/verify.rs
+++ b/chain/src/verify.rs
@@ -1,26 +1,26 @@
-use crate::{delete_unverified_block, UnverifiedBlock};
-use crate::{utils::forkchanges::ForkChanges, GlobalIndex, TruncateRequest, VerifyResult};
-use ckb_channel::{select, Receiver};
-use ckb_error::{is_internal_db_error, Error, InternalErrorKind};
-use ckb_logger::internal::{log_enabled, trace};
+use crate::{GlobalIndex, TruncateRequest, VerifyResult, utils::forkchanges::ForkChanges};
+use crate::{UnverifiedBlock, delete_unverified_block};
+use ckb_channel::{Receiver, select};
+use ckb_error::{Error, InternalErrorKind, is_internal_db_error};
 use ckb_logger::Level::Trace;
+use ckb_logger::internal::{log_enabled, trace};
 use ckb_logger::{debug, error, info, log_enabled_target, trace_target};
 use ckb_merkle_mountain_range::leaf_index_to_mmr_size;
 use ckb_proposal_table::ProposalTable;
-use ckb_shared::block_status::BlockStatus;
 use ckb_shared::Shared;
-use ckb_store::{attach_block_cell, detach_block_cell, ChainStore, StoreTransaction};
+use ckb_shared::block_status::BlockStatus;
+use ckb_store::{ChainStore, StoreTransaction, attach_block_cell, detach_block_cell};
 use ckb_systemtime::unix_time_as_millis;
 use ckb_tx_pool::TxPoolController;
+use ckb_types::H256;
 use ckb_types::core::cell::{
-    resolve_transaction, BlockCellProvider, HeaderChecker, OverlayCellProvider, ResolvedTransaction,
+    BlockCellProvider, HeaderChecker, OverlayCellProvider, ResolvedTransaction, resolve_transaction,
 };
-use ckb_types::core::{service::Request, BlockExt, BlockNumber, BlockView, Cycle, HeaderView};
+use ckb_types::core::{BlockExt, BlockNumber, BlockView, Cycle, HeaderView, service::Request};
 use ckb_types::packed::Byte32;
 use ckb_types::utilities::merkle_mountain_range::ChainRootMMR;
-use ckb_types::H256;
-use ckb_verification::cache::Completed;
 use ckb_verification::InvalidParentError;
+use ckb_verification::cache::Completed;
 use ckb_verification_contextual::{ContextualBlockVerifier, VerifyContext};
 use ckb_verification_traits::Switch;
 use dashmap::DashSet;
diff --git a/ckb-bin/src/helper.rs b/ckb-bin/src/helper.rs
index de27935cb5..9f7e1a266c 100644
--- a/ckb-bin/src/helper.rs
+++ b/ckb-bin/src/helper.rs
@@ -1,6 +1,6 @@
 use ckb_logger::debug;
 
-use std::io::{stdin, stdout, Write};
+use std::io::{Write, stdin, stdout};
 
 #[cfg(not(feature = "deadlock_detection"))]
 pub fn deadlock_detection() {}
diff --git a/ckb-bin/src/lib.rs b/ckb-bin/src/lib.rs
index 04fc2f8741..5f8f9972c9 100644
--- a/ckb-bin/src/lib.rs
+++ b/ckb-bin/src/lib.rs
@@ -57,7 +57,7 @@ pub fn run_app(version: Version) -> Result<(), ExitCode> {
                     match cli {
                         cli::CMD_GEN_SECRET => return Setup::generate(matches),
                         cli::CMD_FROM_SECRET => {
-                            return subcommand::peer_id(Setup::peer_id(matches)?)
+                            return subcommand::peer_id(Setup::peer_id(matches)?);
                         }
                         _ => {}
                     }
diff --git a/ckb-bin/src/setup.rs b/ckb-bin/src/setup.rs
index 79b2595009..101d2cad6e 100644
--- a/ckb-bin/src/setup.rs
+++ b/ckb-bin/src/setup.rs
@@ -1,14 +1,14 @@
 #[cfg(not(target_os = "windows"))]
 use ckb_app_config::DaemonArgs;
 use ckb_app_config::{
-    generate_random_key, read_secret_key, write_secret_to_file, AppConfig, CustomizeSpec, ExitCode,
-    ExportArgs, ImportArgs, InitArgs, MigrateArgs, MinerArgs, PeerIDArgs, ReplayArgs,
-    ResetDataArgs, RunArgs, StatsArgs,
+    AppConfig, CustomizeSpec, ExitCode, ExportArgs, ImportArgs, InitArgs, MigrateArgs, MinerArgs,
+    PeerIDArgs, ReplayArgs, ResetDataArgs, RunArgs, StatsArgs, generate_random_key,
+    read_secret_key, write_secret_to_file,
 };
-use ckb_chain_spec::{consensus::Consensus, ChainSpec};
+use ckb_chain_spec::{ChainSpec, consensus::Consensus};
 use ckb_jsonrpc_types::ScriptHashType;
 use ckb_logger::{error, info};
-use ckb_types::{u256, H256, U256};
+use ckb_types::{H256, U256, u256};
 use clap::ArgMatches;
 use std::{path::PathBuf, str::FromStr};
 
diff --git a/ckb-bin/src/subcommand/daemon.rs b/ckb-bin/src/subcommand/daemon.rs
index 4c55166eab..065a67ab77 100644
--- a/ckb-bin/src/subcommand/daemon.rs
+++ b/ckb-bin/src/subcommand/daemon.rs
@@ -1,6 +1,6 @@
 use ckb_app_config::{DaemonArgs, ExitCode};
 use colored::*;
-use nix::sys::signal::{kill, Signal};
+use nix::sys::signal::{Signal, kill};
 use nix::unistd::Pid;
 use std::io::Write;
 use std::path::PathBuf;
diff --git a/ckb-bin/src/subcommand/init.rs b/ckb-bin/src/subcommand/init.rs
index b8a72905f8..7850456785 100644
--- a/ckb-bin/src/subcommand/init.rs
+++ b/ckb-bin/src/subcommand/init.rs
@@ -7,10 +7,10 @@ use ckb_app_config::{AppConfig, ExitCode, InitArgs};
 use ckb_chain_spec::ChainSpec;
 use ckb_jsonrpc_types::ScriptHashType;
 use ckb_resource::{
-    Resource, TemplateContext, AVAILABLE_SPECS, CKB_CONFIG_FILE_NAME, DB_OPTIONS_FILE_NAME,
-    MINER_CONFIG_FILE_NAME, SPEC_DEV_FILE_NAME,
+    AVAILABLE_SPECS, CKB_CONFIG_FILE_NAME, DB_OPTIONS_FILE_NAME, MINER_CONFIG_FILE_NAME, Resource,
+    SPEC_DEV_FILE_NAME, TemplateContext,
 };
-use ckb_types::{prelude::*, H256};
+use ckb_types::{H256, prelude::*};
 
 use crate::cli;
 
@@ -131,7 +131,9 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
             )
         }
         None => {
-            eprintln!("WARN: Mining feature is disabled because of the lack of the block assembler config options.");
+            eprintln!(
+                "WARN: Mining feature is disabled because of the lack of the block assembler config options."
+            );
             format!(
                 "# secp256k1_blake160_sighash_all example:\n\
                  # [block_assembler]\n\
diff --git a/ckb-bin/src/subcommand/list_hashes.rs b/ckb-bin/src/subcommand/list_hashes.rs
index b241d92eef..49df288bfa 100644
--- a/ckb-bin/src/subcommand/list_hashes.rs
+++ b/ckb-bin/src/subcommand/list_hashes.rs
@@ -1,7 +1,7 @@
 use ckb_app_config::{CKBAppConfig, ExitCode};
 use ckb_chain_spec::ChainSpec;
-use ckb_resource::{Resource, AVAILABLE_SPECS};
-use ckb_types::{packed::CellOutput, prelude::*, H256};
+use ckb_resource::{AVAILABLE_SPECS, Resource};
+use ckb_types::{H256, packed::CellOutput, prelude::*};
 use ckb_util::LinkedHashMap;
 use clap::ArgMatches;
 use serde::{Deserialize, Serialize};
diff --git a/ckb-bin/src/subcommand/migrate.rs b/ckb-bin/src/subcommand/migrate.rs
index 43cca15693..5a612de71b 100644
--- a/ckb-bin/src/subcommand/migrate.rs
+++ b/ckb-bin/src/subcommand/migrate.rs
@@ -45,7 +45,8 @@ pub fn migrate(args: MigrateArgs) -> Result<(), ExitCode> {
 
             if migrate.require_expensive(&db, args.include_background) && !args.force {
                 if std::io::stdin().is_terminal() && std::io::stdout().is_terminal() {
-                    let input = prompt("\
+                    let input = prompt(
+                        "\
                     \n\
                     Doing migration will take quite a long time before CKB could work again.\n\
                     \n\
diff --git a/ckb-bin/src/subcommand/run.rs b/ckb-bin/src/subcommand/run.rs
index f65f8d1f49..9c253aaa15 100644
--- a/ckb-bin/src/subcommand/run.rs
+++ b/ckb-bin/src/subcommand/run.rs
@@ -2,7 +2,7 @@ use std::thread::available_parallelism;
 
 use crate::helper::deadlock_detection;
 use ckb_app_config::{ExitCode, RunArgs};
-use ckb_async_runtime::{new_global_runtime, Handle};
+use ckb_async_runtime::{Handle, new_global_runtime};
 use ckb_build_info::Version;
 use ckb_launcher::Launcher;
 use ckb_logger::info;
diff --git a/db-migration/src/lib.rs b/db-migration/src/lib.rs
index d3aa913325..af9a329d76 100644
--- a/db-migration/src/lib.rs
+++ b/db-migration/src/lib.rs
@@ -1,7 +1,7 @@
 //! TODO(doc): @quake
+use ckb_channel::Receiver;
 use ckb_channel::select;
 use ckb_channel::unbounded;
-use ckb_channel::Receiver;
 use ckb_db::{ReadOnlyDB, RocksDB};
 use ckb_db_schema::{COLUMN_META, META_TIP_HEADER_KEY, MIGRATION_VERSION_KEY};
 use ckb_error::{Error, InternalErrorKind};
diff --git a/db/src/db.rs b/db/src/db.rs
index 5845f6c047..40ec4ce330 100644
--- a/db/src/db.rs
+++ b/db/src/db.rs
@@ -2,7 +2,7 @@
 use crate::snapshot::RocksDBSnapshot;
 use crate::transaction::RocksDBTransaction;
 use crate::write_batch::RocksDBWriteBatch;
-use crate::{internal_error, Result};
+use crate::{Result, internal_error};
 use ckb_app_config::DBConfig;
 use ckb_db_schema::Col;
 use ckb_logger::info;
@@ -11,9 +11,9 @@ use rocksdb::ops::{
     Put, SetOptions, WriteOps,
 };
 use rocksdb::{
-    ffi, BlockBasedIndexType, BlockBasedOptions, Cache, ColumnFamily, ColumnFamilyDescriptor,
+    BlockBasedIndexType, BlockBasedOptions, Cache, ColumnFamily, ColumnFamilyDescriptor,
     DBPinnableSlice, FullOptions, IteratorMode, OptimisticTransactionDB,
-    OptimisticTransactionOptions, Options, SliceTransform, WriteBatch, WriteOptions,
+    OptimisticTransactionOptions, Options, SliceTransform, WriteBatch, WriteOptions, ffi,
 };
 use std::path::Path;
 use std::sync::Arc;
diff --git a/db/src/db_with_ttl.rs b/db/src/db_with_ttl.rs
index cdb7640ab9..7e3e1df2f6 100644
--- a/db/src/db_with_ttl.rs
+++ b/db/src/db_with_ttl.rs
@@ -1,6 +1,6 @@
 //! DB with ttl support wrapper
 
-use crate::{internal_error, Result};
+use crate::{Result, internal_error};
 use rocksdb::ops::{DropCF, GetColumnFamilys, GetPinnedCF, GetPropertyCF, OpenCF, PutCF};
 use rocksdb::{
     ColumnFamilyDescriptor, DBPinnableSlice, DBWithTTL as RawDBWithTTL, Options, TTLOpenDescriptor,
diff --git a/db/src/iter.rs b/db/src/iter.rs
index 440a137210..e165357272 100644
--- a/db/src/iter.rs
+++ b/db/src/iter.rs
@@ -1,12 +1,12 @@
 //! RocksDB iterator wrapper base on DBIter
 use crate::db::cf_handle;
 use crate::{
-    internal_error, Result, RocksDB, RocksDBSnapshot, RocksDBTransaction,
-    RocksDBTransactionSnapshot,
+    Result, RocksDB, RocksDBSnapshot, RocksDBTransaction, RocksDBTransactionSnapshot,
+    internal_error,
 };
 use ckb_db_schema::Col;
-use rocksdb::{ops::IterateCF, ReadOptions};
 pub use rocksdb::{DBIterator as DBIter, Direction, IteratorMode};
+use rocksdb::{ReadOptions, ops::IterateCF};
 
 /// An iterator over a column family, with specifiable ranges and direction.
 pub trait DBIterator {
diff --git a/db/src/read_only_db.rs b/db/src/read_only_db.rs
index 0f8dfe0bc8..498a8f5a7c 100644
--- a/db/src/read_only_db.rs
+++ b/db/src/read_only_db.rs
@@ -1,5 +1,5 @@
 //! ReadOnlyDB wrapper base on rocksdb read_only_open mode
-use crate::{internal_error, Result};
+use crate::{Result, internal_error};
 use ckb_db_schema::Col;
 use ckb_logger::info;
 use rocksdb::ops::{GetColumnFamilys, GetPinned, GetPinnedCF, OpenCF};
diff --git a/db/src/snapshot.rs b/db/src/snapshot.rs
index 18dffba891..4e5ef7e550 100644
--- a/db/src/snapshot.rs
+++ b/db/src/snapshot.rs
@@ -1,12 +1,12 @@
 //! RocksDB snapshot wrapper
 use crate::db::cf_handle;
-use crate::{internal_error, Result};
+use crate::{Result, internal_error};
 use ckb_db_schema::Col;
 use libc::{self, c_char, size_t};
 use rocksdb::ops::{GetPinnedCF, Iterate, IterateCF, Read};
 use rocksdb::{
-    ffi, ffi_util, ColumnFamily, ConstHandle, DBPinnableSlice, DBRawIterator, Error, Handle,
-    OptimisticTransactionDB, ReadOptions,
+    ColumnFamily, ConstHandle, DBPinnableSlice, DBRawIterator, Error, Handle,
+    OptimisticTransactionDB, ReadOptions, ffi, ffi_util,
 };
 use std::sync::Arc;
 
diff --git a/db/src/transaction.rs b/db/src/transaction.rs
index f408c89fda..dadfe540eb 100644
--- a/db/src/transaction.rs
+++ b/db/src/transaction.rs
@@ -1,6 +1,6 @@
 //! RocksDB optimistic transaction wrapper
 use crate::db::cf_handle;
-use crate::{internal_error, Result};
+use crate::{Result, internal_error};
 use ckb_db_schema::Col;
 use rocksdb::ops::{DeleteCF, GetPinnedCF, PutCF};
 pub use rocksdb::{DBPinnableSlice, DBVector};
diff --git a/db/src/write_batch.rs b/db/src/write_batch.rs
index d12b071116..c92ec69615 100644
--- a/db/src/write_batch.rs
+++ b/db/src/write_batch.rs
@@ -1,6 +1,6 @@
 //! RocksDB write batch wrapper
 use crate::db::cf_handle;
-use crate::{internal_error, Result};
+use crate::{Result, internal_error};
 use ckb_db_schema::Col;
 use rocksdb::{OptimisticTransactionDB, WriteBatch};
 use std::sync::Arc;
diff --git a/devtools/doc/rpc-gen/src/syn.rs b/devtools/doc/rpc-gen/src/syn.rs
index 1d20d1610e..7669e751dd 100644
--- a/devtools/doc/rpc-gen/src/syn.rs
+++ b/devtools/doc/rpc-gen/src/syn.rs
@@ -5,7 +5,7 @@
 use proc_macro2::TokenTree;
 use std::collections::HashMap;
 use syn::visit::Visit;
-use syn::{parse2, Expr, ItemType, Meta, MetaNameValue};
+use syn::{Expr, ItemType, Meta, MetaNameValue, parse2};
 use walkdir::WalkDir;
 
 pub(crate) struct CommentFinder {
diff --git a/error/src/convert.rs b/error/src/convert.rs
index 73c49f0a88..c753b6f3d2 100644
--- a/error/src/convert.rs
+++ b/error/src/convert.rs
@@ -1,6 +1,6 @@
 use crate::{
-    impl_error_conversion_with_adaptor, impl_error_conversion_with_kind, Error, InternalError,
-    InternalErrorKind,
+    Error, InternalError, InternalErrorKind, impl_error_conversion_with_adaptor,
+    impl_error_conversion_with_kind,
 };
 
 impl_error_conversion_with_kind!(
diff --git a/freezer/src/freezer.rs b/freezer/src/freezer.rs
index b9a668428c..5fd57052cb 100644
--- a/freezer/src/freezer.rs
+++ b/freezer/src/freezer.rs
@@ -11,8 +11,8 @@ use fs2::FileExt;
 use std::collections::BTreeMap;
 use std::fs::{File, OpenOptions};
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 
 const LOCKNAME: &str = "FLOCK";
 
diff --git a/freezer/src/freezer_files.rs b/freezer/src/freezer_files.rs
index 5b4845721e..02f4c954ba 100644
--- a/freezer/src/freezer_files.rs
+++ b/freezer/src/freezer_files.rs
@@ -6,8 +6,8 @@ use std::io::{Error as IoError, ErrorKind as IoErrorKind};
 use std::io::{Read, Write};
 use std::io::{Seek, SeekFrom};
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
 
 const MAX_FILE_SIZE: u64 = 2 * 1_000 * 1_000 * 1_000; // 2G
 const OPEN_FILES_LIMIT: usize = 256;
diff --git a/miner/src/client.rs b/miner/src/client.rs
index 158922d708..2a4739f940 100644
--- a/miner/src/client.rs
+++ b/miner/src/client.rs
@@ -5,18 +5,18 @@ use ckb_async_runtime::Handle;
 use ckb_channel::Sender;
 use ckb_jsonrpc_types::{Block as JsonBlock, BlockTemplate};
 use ckb_logger::{debug, error, info};
-use ckb_stop_handler::{new_tokio_exit_rx, CancellationToken};
+use ckb_stop_handler::{CancellationToken, new_tokio_exit_rx};
 use ckb_types::{
-    packed::{Block, Byte32},
     H256,
+    packed::{Block, Byte32},
 };
 use futures::prelude::*;
 use http_body_util::{BodyExt, Empty, Full};
 use hyper::{
+    Error as HyperError, Request, Response, Uri,
     body::{Buf, Bytes},
-    header::{HeaderValue, CONTENT_TYPE},
+    header::{CONTENT_TYPE, HeaderValue},
     service::service_fn,
-    Error as HyperError, Request, Response, Uri,
 };
 use hyper_util::{
     client::legacy::{Client as HttpClient, Error as ClientError},
@@ -28,10 +28,10 @@ use jsonrpc_core::{
     request::MethodCall, response::Output, version::Version,
 };
 use serde_json::error::Error as JsonError;
-use serde_json::{self, json, Value};
+use serde_json::{self, Value, json};
 use std::net::SocketAddr;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::{convert::Into, time};
 use tokio::{
     net::TcpListener,
diff --git a/miner/src/miner.rs b/miner/src/miner.rs
index 436ea53ca4..25ea383d01 100644
--- a/miner/src/miner.rs
+++ b/miner/src/miner.rs
@@ -1,8 +1,8 @@
-use crate::client::{Client, Works};
-use crate::worker::{start_worker, WorkerController, WorkerMessage};
 use crate::Work;
+use crate::client::{Client, Works};
+use crate::worker::{WorkerController, WorkerMessage, start_worker};
 use ckb_app_config::MinerWorkerConfig;
-use ckb_channel::{select, unbounded, Receiver};
+use ckb_channel::{Receiver, select, unbounded};
 use ckb_logger::{debug, error, info};
 use ckb_pow::PowEngine;
 use ckb_stop_handler::broadcast_exit_signals;
diff --git a/miner/src/worker/eaglesong_simple.rs b/miner/src/worker/eaglesong_simple.rs
index 22e91e70f1..8d6c4720a4 100644
--- a/miner/src/worker/eaglesong_simple.rs
+++ b/miner/src/worker/eaglesong_simple.rs
@@ -5,7 +5,7 @@ use ckb_channel::{Receiver, Sender};
 use ckb_hash::blake2b_256;
 use ckb_logger::{debug, error};
 use ckb_pow::pow_message;
-use ckb_types::{packed::Byte32, U256};
+use ckb_types::{U256, packed::Byte32};
 use eaglesong::eaglesong;
 use indicatif::ProgressBar;
 use std::thread;
diff --git a/miner/src/worker/mod.rs b/miner/src/worker/mod.rs
index ac27e72519..8736509c04 100644
--- a/miner/src/worker/mod.rs
+++ b/miner/src/worker/mod.rs
@@ -3,14 +3,14 @@ mod eaglesong_simple;
 
 use crate::Work;
 use ckb_app_config::MinerWorkerConfig;
-use ckb_channel::{unbounded, Sender};
+use ckb_channel::{Sender, unbounded};
 use ckb_logger::error;
 use ckb_pow::{DummyPowEngine, EaglesongBlake2bPowEngine, EaglesongPowEngine, PowEngine};
-use ckb_types::{packed::Byte32, U256};
+use ckb_types::{U256, packed::Byte32};
 use dummy::Dummy;
 use eaglesong_simple::EaglesongSimple;
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
-use rand::{random, Rng};
+use rand::{Rng, random};
 use std::ops::Range;
 use std::sync::Arc;
 use std::thread;
diff --git a/network/src/benches/peer_store.rs b/network/src/benches/peer_store.rs
index c7d288e7b3..9637f02dec 100644
--- a/network/src/benches/peer_store.rs
+++ b/network/src/benches/peer_store.rs
@@ -4,7 +4,7 @@ extern crate criterion;
 extern crate ckb_network;
 extern crate ckb_util;
 
-use ckb_network::{multiaddr::Multiaddr, peer_store::PeerStore, Flags, PeerId};
+use ckb_network::{Flags, PeerId, multiaddr::Multiaddr, peer_store::PeerStore};
 use criterion::{BatchSize, BenchmarkId, Criterion};
 
 const SIZES: &[usize] = &[10_000, 20_000];
diff --git a/network/src/compress.rs b/network/src/compress.rs
index 597ee473a7..ed63a2680c 100644
--- a/network/src/compress.rs
+++ b/network/src/compress.rs
@@ -2,7 +2,7 @@
 
 use ckb_logger::debug;
 use p2p::bytes::{BufMut, Bytes, BytesMut};
-use snap::raw::{decompress_len, Decoder as SnapDecoder, Encoder as SnapEncoder};
+use snap::raw::{Decoder as SnapDecoder, Encoder as SnapEncoder, decompress_len};
 
 use std::io;
 
diff --git a/network/src/errors.rs b/network/src/errors.rs
index 0e3bb8d496..b408b791ed 100644
--- a/network/src/errors.rs
+++ b/network/src/errors.rs
@@ -1,11 +1,11 @@
 //! Error module
 use p2p::{
+    SessionId,
     error::{
         DialerErrorKind, ListenErrorKind, ProtocolHandleErrorKind, SendErrorKind,
         TransportErrorKind,
     },
     secio::PeerId,
-    SessionId,
 };
 use std::fmt;
 use std::fmt::Display;
diff --git a/network/src/lib.rs b/network/src/lib.rs
index c672dab65a..66747dccc2 100644
--- a/network/src/lib.rs
+++ b/network/src/lib.rs
@@ -32,19 +32,18 @@ pub use crate::{
     peer_registry::PeerRegistry,
     peer_store::Score,
     protocols::{
-        identify::Flags, support_protocols::SupportProtocols, BoxedCKBProtocolContext, CKBProtocol,
-        CKBProtocolContext, CKBProtocolHandler, PeerIndex,
+        BoxedCKBProtocolContext, CKBProtocol, CKBProtocolContext, CKBProtocolHandler, PeerIndex,
+        identify::Flags, support_protocols::SupportProtocols,
     },
 };
 pub use p2p::{
-    async_trait,
+    ProtocolId, SessionId, async_trait,
     builder::ServiceBuilder,
     bytes, multiaddr, runtime,
     secio::{self, PeerId, PublicKey},
     service::{ServiceControl, SessionType, TargetProtocol, TargetSession},
     traits::ServiceProtocol,
     utils::{extract_peer_id, multiaddr_to_socketaddr},
-    ProtocolId, SessionId,
 };
 pub use tokio;
 
diff --git a/network/src/network.rs b/network/src/network.rs
index 87ca4cc46d..a4d31b4df7 100644
--- a/network/src/network.rs
+++ b/network/src/network.rs
@@ -4,8 +4,8 @@ use crate::errors::Error;
 use crate::errors::P2PError;
 use crate::peer_registry::{ConnectionStatus, PeerRegistry};
 use crate::peer_store::{
-    types::{AddrInfo, BannedAddr},
     PeerStore,
+    types::{AddrInfo, BannedAddr},
 };
 use crate::protocols::{
     disconnect_message::DisconnectMessageProtocol,
@@ -20,22 +20,22 @@ use crate::services::{
     protocol_type_checker::ProtocolTypeCheckerService,
 };
 use crate::{Behaviour, CKBProtocol, Peer, PeerIndex, ProtocolId, ServiceControl};
-use ckb_app_config::{default_support_all_protocols, NetworkConfig, SupportProtocol};
+use ckb_app_config::{NetworkConfig, SupportProtocol, default_support_all_protocols};
 use ckb_logger::{debug, error, info, trace, warn};
 use ckb_spawn::Spawn;
-use ckb_stop_handler::{broadcast_exit_signals, new_tokio_exit_rx, CancellationToken};
+use ckb_stop_handler::{CancellationToken, broadcast_exit_signals, new_tokio_exit_rx};
 use ckb_systemtime::{Duration, Instant};
 use ckb_util::{Condvar, Mutex, RwLock};
-use futures::{channel::mpsc::Sender, Future};
+use futures::{Future, channel::mpsc::Sender};
 use ipnetwork::IpNetwork;
 use p2p::{
-    async_trait,
+    SessionId, async_trait,
     builder::ServiceBuilder,
     bytes::Bytes,
     context::{ServiceContext, SessionContext},
     error::{DialerErrorKind, HandshakeErrorKind, ProtocolHandleErrorKind, SendErrorKind},
     multiaddr::{Multiaddr, Protocol},
-    secio::{self, error::SecioError, PeerId, SecioKeyPair},
+    secio::{self, PeerId, SecioKeyPair, error::SecioError},
     service::{
         ProtocolHandle, Service, ServiceAsyncControl, ServiceError, ServiceEvent, TargetProtocol,
         TargetSession,
@@ -43,11 +43,10 @@ use p2p::{
     traits::ServiceHandle,
     utils::{extract_peer_id, is_reachable, multiaddr_to_socketaddr},
     yamux::config::Config as YamuxConfig,
-    SessionId,
 };
 use rand::prelude::IteratorRandom;
 #[cfg(feature = "with_sentry")]
-use sentry::{capture_message, with_scope, Level};
+use sentry::{Level, capture_message, with_scope};
 #[cfg(not(target_family = "wasm"))]
 use std::sync::mpsc;
 use std::{
@@ -56,8 +55,8 @@ use std::{
     collections::{HashMap, HashSet},
     pin::Pin,
     sync::{
-        atomic::{AtomicBool, Ordering},
         Arc,
+        atomic::{AtomicBool, Ordering},
     },
     thread,
 };
@@ -391,8 +390,7 @@ impl NetworkState {
         if self.public_addrs.read().contains(addr) {
             trace!(
                 "Do not dial listened address(self): {:?}, {}",
-                peer_id,
-                addr
+                peer_id, addr
             );
             return false;
         }
@@ -408,8 +406,7 @@ impl NetworkState {
         if let Some(dial_started) = self.dialing_addrs.read().get(peer_id) {
             trace!(
                 "Do not send repeated dial commands to network service: {:?}, {}",
-                peer_id,
-                addr
+                peer_id, addr
             );
             if Instant::now().saturating_duration_since(*dial_started) > DIAL_HANG_TIMEOUT {
                 #[cfg(feature = "with_sentry")]
@@ -705,12 +702,16 @@ impl ServiceHandle for EventHandler {
                         |scope| scope.set_fingerprint(Some(&["ckb-network", "p2p-service-error"])),
                         || {
                             capture_message(
-                                &format!("ProtocolHandleError: AbnormallyClosed, proto_id: {opt_session_id:?}, session id: {opt_session_id:?}"),
+                                &format!(
+                                    "ProtocolHandleError: AbnormallyClosed, proto_id: {opt_session_id:?}, session id: {opt_session_id:?}"
+                                ),
                                 Level::Warning,
                             )
                         },
                     );
-                    error!("ProtocolHandleError: AbnormallyClosed, proto_id: {opt_session_id:?}, session id: {opt_session_id:?}");
+                    error!(
+                        "ProtocolHandleError: AbnormallyClosed, proto_id: {opt_session_id:?}, session id: {opt_session_id:?}"
+                    );
 
                     broadcast_exit_signals();
                 }
diff --git a/network/src/peer.rs b/network/src/peer.rs
index fe7ee3dfb3..298f9fc1ea 100644
--- a/network/src/peer.rs
+++ b/network/src/peer.rs
@@ -1,6 +1,6 @@
 use crate::network_group::Group;
 use crate::{
-    multiaddr::Multiaddr, protocols::identify::Flags, ProtocolId, ProtocolVersion, SessionType,
+    ProtocolId, ProtocolVersion, SessionType, multiaddr::Multiaddr, protocols::identify::Flags,
 };
 use ckb_systemtime::{Duration, Instant};
 use p2p::SessionId;
diff --git a/network/src/peer_registry.rs b/network/src/peer_registry.rs
index c1719c99ad..cdc3a97944 100644
--- a/network/src/peer_registry.rs
+++ b/network/src/peer_registry.rs
@@ -1,14 +1,15 @@
 //! Peer registry
+use crate::Flags;
 use crate::network_group::Group;
 use crate::peer_store::PeerStore;
-use crate::Flags;
 use crate::{
+    Peer, PeerId, SessionType,
     errors::{Error, PeerError},
-    extract_peer_id, Peer, PeerId, SessionType,
+    extract_peer_id,
 };
 use ckb_logger::debug;
 use ckb_systemtime::Instant;
-use p2p::{multiaddr::Multiaddr, SessionId};
+use p2p::{SessionId, multiaddr::Multiaddr};
 use rand::seq::SliceRandom;
 use rand::thread_rng;
 use std::collections::{HashMap, HashSet};
diff --git a/network/src/peer_store/ban_list.rs b/network/src/peer_store/ban_list.rs
index 743e356665..fd6571131e 100644
--- a/network/src/peer_store/ban_list.rs
+++ b/network/src/peer_store/ban_list.rs
@@ -1,6 +1,6 @@
 //! Ban list
-use crate::peer_store::types::{ip_to_network, BannedAddr};
 use crate::peer_store::Multiaddr;
+use crate::peer_store::types::{BannedAddr, ip_to_network};
 use ckb_systemtime::unix_time_as_millis;
 use ipnetwork::IpNetwork;
 use p2p::utils::multiaddr_to_socketaddr;
diff --git a/network/src/peer_store/browser.rs b/network/src/peer_store/browser.rs
index 691c88c34a..f368ff3610 100644
--- a/network/src/peer_store/browser.rs
+++ b/network/src/peer_store/browser.rs
@@ -4,7 +4,7 @@ use idb::{
 };
 use p2p::runtime;
 use serde::{Deserialize, Serialize};
-use tokio::sync::{mpsc::channel, OnceCell};
+use tokio::sync::{OnceCell, mpsc::channel};
 
 use std::path::Path;
 
diff --git a/network/src/peer_store/mod.rs b/network/src/peer_store/mod.rs
index 0fade21e7d..1afb65f6e4 100644
--- a/network/src/peer_store/mod.rs
+++ b/network/src/peer_store/mod.rs
@@ -18,8 +18,8 @@ pub mod types;
 pub(crate) use crate::Behaviour;
 pub use crate::SessionType;
 use p2p::multiaddr::{Multiaddr, Protocol};
-pub(crate) use peer_store_impl::required_flags_filter;
 pub use peer_store_impl::PeerStore;
+pub(crate) use peer_store_impl::required_flags_filter;
 
 /// peer store evict peers after reach this limitation
 pub(crate) const ADDR_COUNT_LIMIT: usize = 16384;
diff --git a/network/src/peer_store/peer_store_db.rs b/network/src/peer_store/peer_store_db.rs
index 64b9dd8984..c03296a4ce 100644
--- a/network/src/peer_store/peer_store_db.rs
+++ b/network/src/peer_store/peer_store_db.rs
@@ -1,16 +1,16 @@
 use crate::{
     errors::{Error, PeerStoreError},
     peer_store::{
+        PeerStore,
         addr_manager::AddrManager,
         ban_list::BanList,
         types::{AddrInfo, BannedAddr},
-        PeerStore,
     },
 };
 use ckb_logger::{debug, error};
 use std::path::Path;
 use std::{
-    fs::{copy, create_dir_all, remove_file, rename, File, OpenOptions},
+    fs::{File, OpenOptions, copy, create_dir_all, remove_file, rename},
     io::{Read, Write},
 };
 
diff --git a/network/src/peer_store/peer_store_impl.rs b/network/src/peer_store/peer_store_impl.rs
index d239511479..3b2f1f9f0d 100644
--- a/network/src/peer_store/peer_store_impl.rs
+++ b/network/src/peer_store/peer_store_impl.rs
@@ -1,20 +1,20 @@
 use crate::{
+    Flags, PeerId, SessionType,
     errors::{PeerStoreError, Result},
     extract_peer_id, multiaddr_to_socketaddr,
     network_group::Group,
     peer_store::{
+        ADDR_COUNT_LIMIT, ADDR_TIMEOUT_MS, ADDR_TRY_TIMEOUT_MS, Behaviour, DIAL_INTERVAL,
+        Multiaddr, PeerScoreConfig, ReportResult, Status,
         addr_manager::AddrManager,
         ban_list::BanList,
         base_addr,
-        types::{ip_to_network, AddrInfo, BannedAddr, PeerInfo},
-        Behaviour, Multiaddr, PeerScoreConfig, ReportResult, Status, ADDR_COUNT_LIMIT,
-        ADDR_TIMEOUT_MS, ADDR_TRY_TIMEOUT_MS, DIAL_INTERVAL,
+        types::{AddrInfo, BannedAddr, PeerInfo, ip_to_network},
     },
-    Flags, PeerId, SessionType,
 };
 use ipnetwork::IpNetwork;
 use rand::prelude::IteratorRandom;
-use std::collections::{hash_map::Entry, HashMap};
+use std::collections::{HashMap, hash_map::Entry};
 
 /// Peer store
 ///
diff --git a/network/src/peer_store/types.rs b/network/src/peer_store/types.rs
index 1f73de7efd..3170fde7e5 100644
--- a/network/src/peer_store/types.rs
+++ b/network/src/peer_store/types.rs
@@ -1,9 +1,9 @@
 //! Type used on peer store
 use crate::{
+    Flags,
     peer_store::{
-        base_addr, Score, SessionType, ADDR_MAX_FAILURES, ADDR_MAX_RETRIES, ADDR_TIMEOUT_MS,
+        ADDR_MAX_FAILURES, ADDR_MAX_RETRIES, ADDR_TIMEOUT_MS, Score, SessionType, base_addr,
     },
-    Flags,
 };
 use ipnetwork::IpNetwork;
 use p2p::multiaddr::{Multiaddr, Protocol};
diff --git a/network/src/protocols/discovery/addr.rs b/network/src/protocols/discovery/addr.rs
index acd0cae369..ec37cc314d 100644
--- a/network/src/protocols/discovery/addr.rs
+++ b/network/src/protocols/discovery/addr.rs
@@ -1,7 +1,7 @@
 use std::collections::hash_map::RandomState;
 
 use bloom_filters::{BloomFilter, DefaultBuildHashKernels, StableBloomFilter};
-use p2p::{context::SessionContext, multiaddr::Multiaddr, ProtocolId, SessionId};
+use p2p::{ProtocolId, SessionId, context::SessionContext, multiaddr::Multiaddr};
 
 use crate::Flags;
 
diff --git a/network/src/protocols/discovery/mod.rs b/network/src/protocols/discovery/mod.rs
index b64ca17141..eaa5e2c61d 100644
--- a/network/src/protocols/discovery/mod.rs
+++ b/network/src/protocols/discovery/mod.rs
@@ -3,12 +3,11 @@ use std::{collections::HashMap, sync::Arc};
 use ckb_logger::{debug, error, trace, warn};
 use ckb_systemtime::{Duration, Instant};
 use p2p::{
-    async_trait, bytes,
+    SessionId, async_trait, bytes,
     context::{ProtocolContext, ProtocolContextMutRef, SessionContext},
     multiaddr::Multiaddr,
     traits::ServiceProtocol,
     utils::{is_reachable, multiaddr_to_socketaddr},
-    SessionId,
 };
 use rand::seq::SliceRandom;
 
diff --git a/network/src/protocols/discovery/state.rs b/network/src/protocols/discovery/state.rs
index 1f1491084c..3e24c405e2 100644
--- a/network/src/protocols/discovery/state.rs
+++ b/network/src/protocols/discovery/state.rs
@@ -2,18 +2,18 @@ use ckb_systemtime::{Duration, Instant};
 
 use ckb_logger::debug;
 use p2p::{
+    SessionId,
     context::{ProtocolContext, ProtocolContextMutRef},
     multiaddr::{Multiaddr, Protocol},
     utils::multiaddr_to_socketaddr,
-    SessionId,
 };
 
 use crate::Flags;
 
 use super::{
-    addr::AddrKnown,
-    protocol::{encode, DiscoveryMessage, Node, Nodes},
     AddressManager, MAX_ADDR_TO_SEND,
+    addr::AddrKnown,
+    protocol::{DiscoveryMessage, Node, Nodes, encode},
 };
 
 // FIXME: should be a more high level version number
diff --git a/network/src/protocols/feeler.rs b/network/src/protocols/feeler.rs
index 6fe688d9d7..e29bda2cc8 100644
--- a/network/src/protocols/feeler.rs
+++ b/network/src/protocols/feeler.rs
@@ -6,7 +6,7 @@ use p2p::{
     context::{ProtocolContext, ProtocolContextMutRef},
     traits::ServiceProtocol,
 };
-use std::sync::{atomic::Ordering, Arc};
+use std::sync::{Arc, atomic::Ordering};
 
 /// Feeler
 /// Currently do nothing, CKBProtocol auto refresh peer_store after connected.
diff --git a/network/src/protocols/identify/mod.rs b/network/src/protocols/identify/mod.rs
index 84f2f3ffd7..bd07188e54 100644
--- a/network/src/protocols/identify/mod.rs
+++ b/network/src/protocols/identify/mod.rs
@@ -1,23 +1,22 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
-use std::sync::{atomic::Ordering, Arc};
+use std::sync::{Arc, atomic::Ordering};
 
 use ckb_logger::{debug, error, trace, warn};
 use ckb_systemtime::{Duration, Instant};
 use p2p::{
-    async_trait,
+    SessionId, async_trait,
     bytes::Bytes,
     context::{ProtocolContext, ProtocolContextMutRef, SessionContext},
     multiaddr::{Multiaddr, Protocol},
     service::{SessionType, TargetProtocol},
     traits::ServiceProtocol,
     utils::{extract_peer_id, is_reachable, multiaddr_to_socketaddr},
-    SessionId,
 };
 
 mod protocol;
 
-use crate::{peer_store::required_flags_filter, NetworkState, PeerIdentifyInfo, SupportProtocols};
+use crate::{NetworkState, PeerIdentifyInfo, SupportProtocols, peer_store::required_flags_filter};
 use ckb_types::{packed, prelude::*};
 
 use protocol::IdentifyMessage;
@@ -488,7 +487,9 @@ impl Callback for IdentifyCallback {
                             .await;
                     } else {
                         // The remote end cannot support all local protocols.
-                        warn!("Session closed from IdentifyProtocol due to peer's flag not meeting the requirements");
+                        warn!(
+                            "Session closed from IdentifyProtocol due to peer's flag not meeting the requirements"
+                        );
                         return MisbehaveResult::Disconnect;
                     }
                 }
@@ -505,8 +506,7 @@ impl Callback for IdentifyCallback {
     fn add_remote_listen_addrs(&mut self, session: &SessionContext, addrs: Vec<Multiaddr>) {
         trace!(
             "IdentifyProtocol add remote listening addresses, session: {:?}, addresses : {:?}",
-            session,
-            addrs,
+            session, addrs,
         );
         let flags = self.network_state.with_peer_registry_mut(|reg| {
             if let Some(peer) = reg.get_peer_mut(session.id) {
diff --git a/network/src/protocols/mod.rs b/network/src/protocols/mod.rs
index 80a117e73b..1ed98d633a 100644
--- a/network/src/protocols/mod.rs
+++ b/network/src/protocols/mod.rs
@@ -11,13 +11,12 @@ mod tests;
 use ckb_logger::{debug, trace};
 use futures::{Future, FutureExt};
 use p2p::{
-    async_trait,
+    ProtocolId, SessionId, async_trait,
     builder::MetaBuilder,
     bytes::Bytes,
     context::{ProtocolContext, ProtocolContextMutRef},
     service::{ProtocolHandle, ProtocolMeta, ServiceAsyncControl, ServiceControl, TargetSession},
     traits::ServiceProtocol,
-    ProtocolId, SessionId,
 };
 use std::{
     pin::Pin,
@@ -33,9 +32,9 @@ pub type PeerIndex = SessionId;
 pub type BoxedFutureTask = Pin<Box<dyn Future<Output = ()> + 'static + Send>>;
 
 use crate::{
+    Behaviour, Error, NetworkState, Peer, ProtocolVersion, SupportProtocols,
     compress::{compress, decompress},
     network::{async_disconnect_with_message, disconnect_with_message},
-    Behaviour, Error, NetworkState, Peer, ProtocolVersion, SupportProtocols,
 };
 
 /// Abstract protocol context
@@ -80,7 +79,7 @@ pub trait CKBProtocolContext: Send {
     async fn async_send_message_to(&self, peer_index: PeerIndex, data: Bytes) -> Result<(), Error>;
     /// Filter broadcast message
     async fn async_filter_broadcast(&self, target: TargetSession, data: Bytes)
-        -> Result<(), Error>;
+    -> Result<(), Error>;
     /// Disconnect session
     async fn async_disconnect(&self, peer_index: PeerIndex, message: &str) -> Result<(), Error>;
     /// Send message through quick queue
diff --git a/network/src/protocols/ping.rs b/network/src/protocols/ping.rs
index 5f692b46b1..1bc698f31e 100644
--- a/network/src/protocols/ping.rs
+++ b/network/src/protocols/ping.rs
@@ -1,18 +1,17 @@
-use crate::network::async_disconnect_with_message;
 use crate::NetworkState;
+use crate::network::async_disconnect_with_message;
 use ckb_logger::{debug, error, trace, warn};
 use ckb_types::{packed, prelude::*};
 use futures::{
-    channel::mpsc::{channel, Receiver, Sender},
+    channel::mpsc::{Receiver, Sender, channel},
     prelude::*,
 };
 use p2p::{
-    async_trait,
+    SessionId, async_trait,
     bytes::Bytes,
     context::{ProtocolContext, ProtocolContextMutRef},
     service::TargetSession,
     traits::ServiceProtocol,
-    SessionId,
 };
 use std::{
     collections::{HashMap, HashSet},
diff --git a/network/src/protocols/tests/discovery.rs b/network/src/protocols/tests/discovery.rs
index 09670f2f58..919650e6ce 100644
--- a/network/src/protocols/tests/discovery.rs
+++ b/network/src/protocols/tests/discovery.rs
@@ -1,5 +1,5 @@
 use crate::protocols::{
-    discovery::protocol::{decode, encode, DiscoveryMessage},
+    discovery::protocol::{DiscoveryMessage, decode, encode},
     identify::Flags,
 };
 
diff --git a/network/src/protocols/tests/mod.rs b/network/src/protocols/tests/mod.rs
index 89b1276901..34ecd4e508 100644
--- a/network/src/protocols/tests/mod.rs
+++ b/network/src/protocols/tests/mod.rs
@@ -7,8 +7,8 @@ use super::{
 };
 
 use crate::{
-    network::EventHandler, services::protocol_type_checker::ProtocolTypeCheckerService,
-    NetworkState, PeerIdentifyInfo, SupportProtocols,
+    NetworkState, PeerIdentifyInfo, SupportProtocols, network::EventHandler,
+    services::protocol_type_checker::ProtocolTypeCheckerService,
 };
 
 use std::{
@@ -20,11 +20,11 @@ use std::{
 
 use ckb_app_config::NetworkConfig;
 use p2p::{
+    ProtocolId, SessionId,
     builder::ServiceBuilder,
     multiaddr::{Multiaddr, Protocol},
     service::{ProtocolHandle, ServiceControl, TargetProtocol},
     utils::multiaddr_to_socketaddr,
-    ProtocolId, SessionId,
 };
 use tempfile::tempdir;
 
@@ -121,12 +121,14 @@ fn net_service_start(
         discovery_local_address: true,
         bootnode_mode: true,
         reuse_port_on_linux: true,
-        public_addresses: vec![format!(
-            "/ip4/225.0.0.1/tcp/42/p2p/{}",
-            crate::PeerId::random().to_base58()
-        )
-        .parse()
-        .unwrap()],
+        public_addresses: vec![
+            format!(
+                "/ip4/225.0.0.1/tcp/42/p2p/{}",
+                crate::PeerId::random().to_base58()
+            )
+            .parse()
+            .unwrap(),
+        ],
         ..Default::default()
     };
 
diff --git a/network/src/services/dns_seeding/seed_record.rs b/network/src/services/dns_seeding/seed_record.rs
index 92bce2ca74..bfacca0bb0 100644
--- a/network/src/services/dns_seeding/seed_record.rs
+++ b/network/src/services/dns_seeding/seed_record.rs
@@ -12,8 +12,8 @@ use p2p::{
     utils::{is_reachable, socketaddr_to_multiaddr},
 };
 use secp256k1::{
-    ecdsa::{RecoverableSignature, RecoveryId},
     Message, PublicKey,
+    ecdsa::{RecoverableSignature, RecoveryId},
 };
 
 pub(crate) static SECP256K1: std::sync::LazyLock<secp256k1::Secp256k1<secp256k1::All>> =
diff --git a/network/src/services/dns_seeding/tests.rs b/network/src/services/dns_seeding/tests.rs
index 79576c74dc..48ae3ab6d3 100644
--- a/network/src/services/dns_seeding/tests.rs
+++ b/network/src/services/dns_seeding/tests.rs
@@ -9,7 +9,7 @@ use std::{
     time::{SystemTime, UNIX_EPOCH},
 };
 
-use crate::services::dns_seeding::seed_record::{SeedRecord, SeedRecordError, SECP256K1, SEP};
+use crate::services::dns_seeding::seed_record::{SECP256K1, SEP, SeedRecord, SeedRecordError};
 
 struct Generator;
 
diff --git a/network/src/services/outbound_peer.rs b/network/src/services/outbound_peer.rs
index 3e8477184b..ee4f6b023c 100644
--- a/network/src/services/outbound_peer.rs
+++ b/network/src/services/outbound_peer.rs
@@ -1,7 +1,7 @@
 use crate::{
-    network::TransportType,
-    peer_store::{types::AddrInfo, PeerStore},
     NetworkState,
+    network::TransportType,
+    peer_store::{PeerStore, types::AddrInfo},
 };
 use ckb_logger::trace;
 use ckb_systemtime::unix_time_as_millis;
diff --git a/network/src/services/protocol_type_checker.rs b/network/src/services/protocol_type_checker.rs
index a4f371ce84..5c335e1dbc 100644
--- a/network/src/services/protocol_type_checker.rs
+++ b/network/src/services/protocol_type_checker.rs
@@ -8,7 +8,7 @@
 /// 2. feeler: only open feeler protocol is open.
 ///
 /// Other protocols will be closed after a timeout.
-use crate::{network::disconnect_with_message, NetworkState, Peer, ProtocolId, SupportProtocols};
+use crate::{NetworkState, Peer, ProtocolId, SupportProtocols, network::disconnect_with_message};
 use ckb_logger::debug;
 use ckb_systemtime::{Duration, Instant};
 use futures::{Future, StreamExt};
diff --git a/network/src/tests/addr_manager.rs b/network/src/tests/addr_manager.rs
index 3803beeba9..a62de6d2cb 100644
--- a/network/src/tests/addr_manager.rs
+++ b/network/src/tests/addr_manager.rs
@@ -1,7 +1,7 @@
 use crate::{
+    PeerId,
     multiaddr::Multiaddr,
     peer_store::{addr_manager::AddrManager, types::AddrInfo},
-    PeerId,
 };
 use proptest::prelude::*;
 use std::net::Ipv4Addr;
diff --git a/network/src/tests/compress.rs b/network/src/tests/compress.rs
index 7213778fac..6166093851 100644
--- a/network/src/tests/compress.rs
+++ b/network/src/tests/compress.rs
@@ -1,6 +1,6 @@
 use p2p::bytes::{Bytes, BytesMut};
 
-use crate::compress::{compress, decompress, Message, COMPRESSION_SIZE_THRESHOLD};
+use crate::compress::{COMPRESSION_SIZE_THRESHOLD, Message, compress, decompress};
 
 #[test]
 fn test_no_need_compress() {
diff --git a/network/src/tests/peer_registry.rs b/network/src/tests/peer_registry.rs
index 99f6dd8686..4e098380ad 100644
--- a/network/src/tests/peer_registry.rs
+++ b/network/src/tests/peer_registry.rs
@@ -2,12 +2,12 @@
 
 use super::random_addr;
 use crate::{
+    PeerId, SessionType,
     errors::{Error, PeerError},
     extract_peer_id,
     multiaddr::Multiaddr,
-    peer_registry::{PeerRegistry, EVICTION_PROTECT_PEERS},
+    peer_registry::{EVICTION_PROTECT_PEERS, PeerRegistry},
     peer_store::PeerStore,
-    PeerId, SessionType,
 };
 use std::time::{Duration, Instant};
 
@@ -77,15 +77,17 @@ fn test_accept_inbound_peer_until_full() {
     );
 
     // test evict a peer
-    assert!(peers
-        .accept_peer(
-            random_addr(),
-            4.into(),
-            SessionType::Inbound,
-            &mut peer_store,
-        )
-        .expect("Accept peer should ok")
-        .is_some());
+    assert!(
+        peers
+            .accept_peer(
+                random_addr(),
+                4.into(),
+                SessionType::Inbound,
+                &mut peer_store,
+            )
+            .expect("Accept peer should ok")
+            .is_some()
+    );
     // should still accept whitelist peer
     peers
         .accept_peer(
@@ -137,14 +139,16 @@ fn test_accept_inbound_peer_eviction() {
     );
     // prepare all peers
     for session_id in 0..protected_peers_count {
-        assert!(peers_registry
-            .accept_peer(
-                random_addr(),
-                session_id.into(),
-                SessionType::Inbound,
-                &mut peer_store,
-            )
-            .is_ok());
+        assert!(
+            peers_registry
+                .accept_peer(
+                    random_addr(),
+                    session_id.into(),
+                    SessionType::Inbound,
+                    &mut peer_store,
+                )
+                .is_ok()
+        );
     }
     let peers: Vec<_> = {
         peers_registry
diff --git a/network/src/tests/peer_store.rs b/network/src/tests/peer_store.rs
index 1832315f02..4e4aa2944b 100644
--- a/network/src/tests/peer_store.rs
+++ b/network/src/tests/peer_store.rs
@@ -1,12 +1,11 @@
 use super::{random_addr, random_addr_v6};
 use crate::{
-    extract_peer_id,
+    Behaviour, Flags, PeerId, SessionType, extract_peer_id,
     multiaddr::Multiaddr,
     peer_store::{
-        ban_list::CLEAR_INTERVAL_COUNTER, types::multiaddr_to_ip_network, PeerStore, Status,
-        ADDR_COUNT_LIMIT, ADDR_TRY_TIMEOUT_MS,
+        ADDR_COUNT_LIMIT, ADDR_TRY_TIMEOUT_MS, PeerStore, Status, ban_list::CLEAR_INTERVAL_COUNTER,
+        types::multiaddr_to_ip_network,
     },
-    Behaviour, Flags, PeerId, SessionType,
 };
 use std::collections::HashSet;
 
@@ -65,9 +64,11 @@ fn test_report() {
     }
 
     assert!(peer_store.report(&addr, Behaviour::TestBad).is_banned());
-    assert!(peer_store
-        .add_addr(addr.clone(), Flags::COMPATIBILITY)
-        .is_ok());
+    assert!(
+        peer_store
+            .add_addr(addr.clone(), Flags::COMPATIBILITY)
+            .is_ok()
+    );
     assert!(peer_store.addr_manager().get(&addr).is_none())
 }
 
@@ -160,9 +161,11 @@ fn test_fetch_addrs_to_attempt() {
     _faketime_guard.set_faketime(1);
 
     let mut peer_store: PeerStore = Default::default();
-    assert!(peer_store
-        .fetch_addrs_to_attempt(1, Flags::COMPATIBILITY, |_| true)
-        .is_empty());
+    assert!(
+        peer_store
+            .fetch_addrs_to_attempt(1, Flags::COMPATIBILITY, |_| true)
+            .is_empty()
+    );
     let addr = random_addr();
     peer_store
         .add_addr(addr.clone(), Flags::COMPATIBILITY)
@@ -181,9 +184,11 @@ fn test_fetch_addrs_to_attempt() {
         1
     );
     peer_store.add_connected_peer(addr, SessionType::Outbound);
-    assert!(peer_store
-        .fetch_addrs_to_attempt(1, Flags::COMPATIBILITY, |_| true)
-        .is_empty());
+    assert!(
+        peer_store
+            .fetch_addrs_to_attempt(1, Flags::COMPATIBILITY, |_| true)
+            .is_empty()
+    );
 }
 
 #[test]
@@ -207,9 +212,11 @@ fn test_fetch_addrs_to_attempt_or_feeler() {
 
     _faketime_guard.set_faketime(100_000 + ADDR_TRY_TIMEOUT_MS + 1);
 
-    assert!(peer_store
-        .fetch_addrs_to_attempt(2, Flags::COMPATIBILITY, |_| true)
-        .is_empty());
+    assert!(
+        peer_store
+            .fetch_addrs_to_attempt(2, Flags::COMPATIBILITY, |_| true)
+            .is_empty()
+    );
     assert_eq!(peer_store.fetch_addrs_to_feeler(2, |_| true).len(), 1);
 }
 
@@ -228,16 +235,20 @@ fn test_fetch_addrs_to_attempt_in_last_minutes() {
     if let Some(paddr) = peer_store.mut_addr_manager().get_mut(&addr) {
         paddr.mark_tried(now);
     }
-    assert!(peer_store
-        .fetch_addrs_to_attempt(1, Flags::COMPATIBILITY, |_| true)
-        .is_empty());
+    assert!(
+        peer_store
+            .fetch_addrs_to_attempt(1, Flags::COMPATIBILITY, |_| true)
+            .is_empty()
+    );
     // after 60 seconds
     if let Some(paddr) = peer_store.mut_addr_manager().get_mut(&addr) {
         paddr.mark_tried(now - 60_001);
     }
-    assert!(peer_store
-        .fetch_addrs_to_attempt(1, Flags::COMPATIBILITY, |_| true)
-        .is_empty());
+    assert!(
+        peer_store
+            .fetch_addrs_to_attempt(1, Flags::COMPATIBILITY, |_| true)
+            .is_empty()
+    );
     peer_store
         .mut_addr_manager()
         .get_mut(&addr)
@@ -291,9 +302,11 @@ fn test_fetch_addrs_to_feeler() {
 #[test]
 fn test_fetch_random_addrs() {
     let mut peer_store: PeerStore = Default::default();
-    assert!(peer_store
-        .fetch_random_addrs(1, Flags::COMPATIBILITY)
-        .is_empty());
+    assert!(
+        peer_store
+            .fetch_random_addrs(1, Flags::COMPATIBILITY)
+            .is_empty()
+    );
     let addr1: Multiaddr = format!("/ip4/225.0.0.1/tcp/42/p2p/{}", PeerId::random().to_base58())
         .parse()
         .unwrap();
@@ -304,14 +317,18 @@ fn test_fetch_random_addrs() {
         .parse()
         .unwrap();
     // random should not return peer that we have never connected to
-    assert!(peer_store
-        .fetch_random_addrs(1, Flags::COMPATIBILITY)
-        .is_empty());
+    assert!(
+        peer_store
+            .fetch_random_addrs(1, Flags::COMPATIBILITY)
+            .is_empty()
+    );
     // can't get peer addr from inbound
     peer_store.add_connected_peer(addr1.clone(), SessionType::Inbound);
-    assert!(peer_store
-        .fetch_random_addrs(1, Flags::COMPATIBILITY)
-        .is_empty());
+    assert!(
+        peer_store
+            .fetch_random_addrs(1, Flags::COMPATIBILITY)
+            .is_empty()
+    );
     // get peer addr from outbound
     peer_store.add_connected_peer(addr1.clone(), SessionType::Outbound);
     peer_store.add_outbound_addr(addr1, Flags::COMPATIBILITY);
@@ -357,9 +374,11 @@ fn test_fetch_random_addrs() {
 #[test]
 fn test_random_fetch_with_filter() {
     let mut peer_store: PeerStore = Default::default();
-    assert!(peer_store
-        .fetch_random_addrs(1, Flags::COMPATIBILITY)
-        .is_empty());
+    assert!(
+        peer_store
+            .fetch_random_addrs(1, Flags::COMPATIBILITY)
+            .is_empty()
+    );
     let addr1: Multiaddr = format!("/ip4/225.0.0.1/tcp/42/p2p/{}", PeerId::random().to_base58())
         .parse()
         .unwrap();
diff --git a/network/src/tests/peer_store_db.rs b/network/src/tests/peer_store_db.rs
index e213039632..48570fad2c 100644
--- a/network/src/tests/peer_store_db.rs
+++ b/network/src/tests/peer_store_db.rs
@@ -1,10 +1,10 @@
 use crate::{
+    PeerId,
     multiaddr::Multiaddr,
     peer_store::{
-        types::{multiaddr_to_ip_network, AddrInfo, BannedAddr},
         PeerStore,
+        types::{AddrInfo, BannedAddr, multiaddr_to_ip_network},
     },
-    PeerId,
 };
 
 use std::fs::File;
diff --git a/notify/src/lib.rs b/notify/src/lib.rs
index 32d09c77e3..76574e5bc4 100644
--- a/notify/src/lib.rs
+++ b/notify/src/lib.rs
@@ -2,10 +2,10 @@
 use ckb_app_config::NotifyConfig;
 use ckb_async_runtime::Handle;
 use ckb_logger::{debug, error, info, trace};
-use ckb_stop_handler::{new_tokio_exit_rx, CancellationToken};
+use ckb_stop_handler::{CancellationToken, new_tokio_exit_rx};
 use ckb_types::packed::Byte32;
 use ckb_types::{
-    core::{tx_pool::Reject, BlockView},
+    core::{BlockView, tx_pool::Reject},
     packed::Alert,
 };
 use std::{collections::HashMap, time::Duration};
diff --git a/pow/src/eaglesong.rs b/pow/src/eaglesong.rs
index f7bb88be27..c80ba83e4f 100644
--- a/pow/src/eaglesong.rs
+++ b/pow/src/eaglesong.rs
@@ -1,5 +1,5 @@
 use super::PowEngine;
-use ckb_types::{packed::Header, prelude::*, utilities::compact_to_target, U256};
+use ckb_types::{U256, packed::Header, prelude::*, utilities::compact_to_target};
 use eaglesong::eaglesong;
 use log::Level::Debug;
 use log::{debug, log_enabled};
diff --git a/pow/src/eaglesong_blake2b.rs b/pow/src/eaglesong_blake2b.rs
index 0b87aed9ad..6e207eda64 100644
--- a/pow/src/eaglesong_blake2b.rs
+++ b/pow/src/eaglesong_blake2b.rs
@@ -1,6 +1,6 @@
 use super::PowEngine;
 use ckb_hash::blake2b_256;
-use ckb_types::{packed::Header, prelude::*, utilities::compact_to_target, U256};
+use ckb_types::{U256, packed::Header, prelude::*, utilities::compact_to_target};
 use eaglesong::eaglesong;
 use log::Level::Debug;
 use log::{debug, log_enabled};
diff --git a/resource/src/lib.rs b/resource/src/lib.rs
index 11e47667bc..3c95e3fa05 100644
--- a/resource/src/lib.rs
+++ b/resource/src/lib.rs
@@ -23,7 +23,7 @@ mod tests;
 
 pub use self::template::Template;
 pub use self::template::{
-    TemplateContext, AVAILABLE_SPECS, DEFAULT_P2P_PORT, DEFAULT_RPC_PORT, DEFAULT_SPEC,
+    AVAILABLE_SPECS, DEFAULT_P2P_PORT, DEFAULT_RPC_PORT, DEFAULT_SPEC, TemplateContext,
 };
 pub use std::io::{Error, Result};
 
diff --git a/resource/src/tests.rs b/resource/src/tests.rs
index c7c2462147..8606a30796 100644
--- a/resource/src/tests.rs
+++ b/resource/src/tests.rs
@@ -1,7 +1,7 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 
-use crate::{Resource, TemplateContext, CKB_CONFIG_FILE_NAME};
+use crate::{CKB_CONFIG_FILE_NAME, Resource, TemplateContext};
 
 fn mkdir() -> tempfile::TempDir {
     tempfile::Builder::new()
diff --git a/rpc/src/error.rs b/rpc/src/error.rs
index ba702456d6..75acaf92d0 100644
--- a/rpc/src/error.rs
+++ b/rpc/src/error.rs
@@ -254,8 +254,13 @@ impl RPCError {
             format!(
                 "This RPC method is in the module `{module}`. \
                  Please modify `rpc.modules`{miner_info} in ckb.toml and restart the ckb node to enable it.",
-                 module = module, miner_info = if module == "Miner" {" and `block_assembler`"} else {""}
-            )
+                module = module,
+                miner_info = if module == "Miner" {
+                    " and `block_assembler`"
+                } else {
+                    ""
+                }
+            ),
         )
     }
 
diff --git a/rpc/src/module/chain.rs b/rpc/src/module/chain.rs
index 9c1bf28ae0..427a18b1f5 100644
--- a/rpc/src/module/chain.rs
+++ b/rpc/src/module/chain.rs
@@ -9,20 +9,20 @@ use ckb_jsonrpc_types::{
 };
 use ckb_logger::error;
 use ckb_reward_calculator::RewardCalculator;
-use ckb_shared::{shared::Shared, Snapshot};
-use ckb_store::{data_loader_wrapper::AsDataLoader, ChainStore};
+use ckb_shared::{Snapshot, shared::Shared};
+use ckb_store::{ChainStore, data_loader_wrapper::AsDataLoader};
 use ckb_traits::HeaderFieldsProvider;
 use ckb_types::core::tx_pool::TransactionWithStatus;
 use ckb_types::{
+    H256,
     core::{
         self,
-        cell::{resolve_transaction, CellProvider, CellStatus, HeaderChecker},
+        cell::{CellProvider, CellStatus, HeaderChecker, resolve_transaction},
         error::OutPointError,
     },
     packed,
     prelude::*,
-    utilities::{merkle_root, MerkleProof, CBMT},
-    H256,
+    utilities::{CBMT, MerkleProof, merkle_root},
 };
 use ckb_verification::ScriptVerifier;
 use ckb_verification::TxVerifyEnv;
diff --git a/rpc/src/module/experiment.rs b/rpc/src/module/experiment.rs
index ba4e93b065..8272c2a618 100644
--- a/rpc/src/module/experiment.rs
+++ b/rpc/src/module/experiment.rs
@@ -6,7 +6,7 @@ use ckb_jsonrpc_types::{
     Capacity, DaoWithdrawingCalculationKind, EstimateCycles, EstimateMode, OutPoint, Transaction,
     Uint64,
 };
-use ckb_shared::{shared::Shared, Snapshot};
+use ckb_shared::{Snapshot, shared::Shared};
 use ckb_store::ChainStore;
 use ckb_types::{core, packed, prelude::*};
 use jsonrpc_core::Result;
diff --git a/rpc/src/module/miner.rs b/rpc/src/module/miner.rs
index 3338c6d5aa..b0c039d416 100644
--- a/rpc/src/module/miner.rs
+++ b/rpc/src/module/miner.rs
@@ -4,10 +4,10 @@ use ckb_chain::ChainController;
 use ckb_jsonrpc_types::{Block, BlockTemplate, Uint64, Version};
 use ckb_logger::{debug, error, info, warn};
 use ckb_network::{NetworkController, PeerIndex, SupportProtocols, TargetSession};
-use ckb_shared::{shared::Shared, Snapshot};
+use ckb_shared::{Snapshot, shared::Shared};
 use ckb_store::ChainStore;
 use ckb_systemtime::unix_time_as_millis;
-use ckb_types::{core, packed, prelude::*, H256};
+use ckb_types::{H256, core, packed, prelude::*};
 use ckb_verification::HeaderVerifier;
 use ckb_verification_traits::Verifier;
 use jsonrpc_core::{Error, Result};
diff --git a/rpc/src/module/mod.rs b/rpc/src/module/mod.rs
index dde6115225..bead61304a 100644
--- a/rpc/src/module/mod.rs
+++ b/rpc/src/module/mod.rs
@@ -136,17 +136,17 @@ pub(crate) use self::stats::StatsRpcImpl;
 pub(crate) use self::subscription::SubscriptionRpcImpl;
 pub(crate) use self::test::IntegrationTestRpcImpl;
 
-pub use self::alert::{add_alert_rpc_methods, alert_rpc_doc, AlertRpc};
-pub use self::chain::{add_chain_rpc_methods, chain_rpc_doc, ChainRpc};
-pub use self::debug::{add_debug_rpc_methods, debug_rpc_doc, DebugRpc};
-pub use self::experiment::{add_experiment_rpc_methods, experiment_rpc_doc, ExperimentRpc};
-pub use self::indexer::{add_indexer_rpc_methods, indexer_rpc_doc, IndexerRpc};
-pub use self::miner::{add_miner_rpc_methods, miner_rpc_doc, MinerRpc};
-pub use self::net::{add_net_rpc_methods, net_rpc_doc, NetRpc};
-pub use self::pool::{add_pool_rpc_methods, pool_rpc_doc, PoolRpc};
-pub use self::rich_indexer::{add_rich_indexer_rpc_methods, rich_indexer_rpc_doc, RichIndexerRpc};
-pub use self::stats::{add_stats_rpc_methods, stats_rpc_doc, StatsRpc};
-pub use self::subscription::{add_subscription_rpc_methods, subscription_rpc_doc, SubscriptionRpc};
+pub use self::alert::{AlertRpc, add_alert_rpc_methods, alert_rpc_doc};
+pub use self::chain::{ChainRpc, add_chain_rpc_methods, chain_rpc_doc};
+pub use self::debug::{DebugRpc, add_debug_rpc_methods, debug_rpc_doc};
+pub use self::experiment::{ExperimentRpc, add_experiment_rpc_methods, experiment_rpc_doc};
+pub use self::indexer::{IndexerRpc, add_indexer_rpc_methods, indexer_rpc_doc};
+pub use self::miner::{MinerRpc, add_miner_rpc_methods, miner_rpc_doc};
+pub use self::net::{NetRpc, add_net_rpc_methods, net_rpc_doc};
+pub use self::pool::{PoolRpc, add_pool_rpc_methods, pool_rpc_doc};
+pub use self::rich_indexer::{RichIndexerRpc, add_rich_indexer_rpc_methods, rich_indexer_rpc_doc};
+pub use self::stats::{StatsRpc, add_stats_rpc_methods, stats_rpc_doc};
+pub use self::subscription::{SubscriptionRpc, add_subscription_rpc_methods, subscription_rpc_doc};
 pub use self::test::{
-    add_integration_test_rpc_methods, integration_test_rpc_doc, IntegrationTestRpc,
+    IntegrationTestRpc, add_integration_test_rpc_methods, integration_test_rpc_doc,
 };
diff --git a/rpc/src/module/net.rs b/rpc/src/module/net.rs
index cbc2f5ad7f..22fd860c7c 100644
--- a/rpc/src/module/net.rs
+++ b/rpc/src/module/net.rs
@@ -5,7 +5,7 @@ use ckb_jsonrpc_types::{
     BannedAddr, LocalNode, LocalNodeProtocol, NodeAddress, PeerSyncState, RemoteNode,
     RemoteNodeProtocol, SyncState, Timestamp,
 };
-use ckb_network::{extract_peer_id, multiaddr::Multiaddr, NetworkController};
+use ckb_network::{NetworkController, extract_peer_id, multiaddr::Multiaddr};
 use ckb_sync::SyncShared;
 use ckb_systemtime::unix_time_as_millis;
 use ckb_types::prelude::{Pack, Unpack};
diff --git a/rpc/src/module/pool.rs b/rpc/src/module/pool.rs
index a9e65da1c3..e13edb5fb3 100644
--- a/rpc/src/module/pool.rs
+++ b/rpc/src/module/pool.rs
@@ -8,7 +8,7 @@ use ckb_jsonrpc_types::{
 use ckb_logger::error;
 use ckb_shared::shared::Shared;
 use ckb_types::core::TransactionView;
-use ckb_types::{core, packed, prelude::*, H256};
+use ckb_types::{H256, core, packed, prelude::*};
 use ckb_verification::{Since, SinceMetric};
 use jsonrpc_core::Result;
 use jsonrpc_utils::rpc;
@@ -515,7 +515,9 @@ impl PoolRpcImpl {
                 format!(
                     "The transaction is rejected by OutputsValidator set in params[1]: {}. \
                     Please check the related information in https://github.com/nervosnetwork/ckb/wiki/Transaction-%C2%BB-Default-Outputs-Validator",
-                    outputs_validator.unwrap_or(OutputsValidator::WellKnownScriptsOnly).json_display()
+                    outputs_validator
+                        .unwrap_or(OutputsValidator::WellKnownScriptsOnly)
+                        .json_display()
                 ),
                 e,
             ));
diff --git a/rpc/src/module/subscription.rs b/rpc/src/module/subscription.rs
index 4036445929..9b60da3402 100644
--- a/rpc/src/module/subscription.rs
+++ b/rpc/src/module/subscription.rs
@@ -3,10 +3,10 @@ use broadcast::error::RecvError;
 use ckb_async_runtime::Handle;
 use ckb_jsonrpc_types::Topic;
 use ckb_logger::error;
-use ckb_notify::NotifyController;
 use ckb_notify::NOTIFY_CHANNEL_SIZE;
+use ckb_notify::NotifyController;
 use ckb_stop_handler::new_tokio_exit_rx;
-use futures_util::{stream::BoxStream, Stream};
+use futures_util::{Stream, stream::BoxStream};
 use jsonrpc_core::Result;
 use jsonrpc_utils::{pub_sub::PublishMsg, rpc};
 use tokio::sync::broadcast;
diff --git a/rpc/src/module/test.rs b/rpc/src/module/test.rs
index 1974b39404..4fe2c13bed 100644
--- a/rpc/src/module/test.rs
+++ b/rpc/src/module/test.rs
@@ -7,19 +7,18 @@ use ckb_jsonrpc_types::{
 };
 use ckb_logger::error;
 use ckb_network::{NetworkController, SupportProtocols};
-use ckb_shared::{shared::Shared, Snapshot};
+use ckb_shared::{Snapshot, shared::Shared};
 use ckb_store::ChainStore;
 use ckb_types::{
+    H256,
     core::{
-        self,
+        self, BlockView,
         cell::{
-            resolve_transaction, OverlayCellProvider, ResolvedTransaction, TransactionsProvider,
+            OverlayCellProvider, ResolvedTransaction, TransactionsProvider, resolve_transaction,
         },
-        BlockView,
     },
     packed,
     prelude::*,
-    H256,
 };
 use ckb_verification_traits::Switch;
 use jsonrpc_core::Result;
@@ -784,7 +783,9 @@ impl IntegrationTestRpc for IntegrationTestRpcImpl {
                 format!(
                     "The transaction is rejected by OutputsValidator set in params[1]: {}. \
                     Please check the related information in https://github.com/nervosnetwork/ckb/wiki/Transaction-%C2%BB-Default-Outputs-Validator",
-                    outputs_validator.unwrap_or(OutputsValidator::WellKnownScriptsOnly).json_display()
+                    outputs_validator
+                        .unwrap_or(OutputsValidator::WellKnownScriptsOnly)
+                        .json_display()
                 ),
                 e,
             ));
diff --git a/rpc/src/server.rs b/rpc/src/server.rs
index e32a263a22..2eb055433a 100644
--- a/rpc/src/server.rs
+++ b/rpc/src/server.rs
@@ -7,21 +7,21 @@ use ckb_async_runtime::Handle;
 use ckb_error::AnyError;
 use ckb_logger::info;
 
-use axum::{body::Bytes, http::StatusCode, response::Response, Json};
+use axum::{Json, body::Bytes, http::StatusCode, response::Response};
 
 use jsonrpc_core::{MetaIoHandler, Metadata, Request};
 
-use ckb_stop_handler::{new_tokio_exit_rx, CancellationToken};
+use ckb_stop_handler::{CancellationToken, new_tokio_exit_rx};
 use futures_util::future;
 use futures_util::future::Either::{Left, Right};
-use jsonrpc_core::types::error::ErrorCode;
-use jsonrpc_core::types::Response as RpcResponse;
 use jsonrpc_core::Error;
+use jsonrpc_core::types::Response as RpcResponse;
+use jsonrpc_core::types::error::ErrorCode;
 
 use futures_util::{SinkExt, TryStreamExt};
 use jsonrpc_utils::axum_utils::handle_jsonrpc_ws;
 use jsonrpc_utils::pub_sub::Session;
-use jsonrpc_utils::stream::{serve_stream_sink, StreamMsg, StreamServerConfig};
+use jsonrpc_utils::stream::{StreamMsg, StreamServerConfig, serve_stream_sink};
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::sync::Arc;
 use std::sync::OnceLock;
diff --git a/rpc/src/service_builder.rs b/rpc/src/service_builder.rs
index c71dea35fe..0435806301 100644
--- a/rpc/src/service_builder.rs
+++ b/rpc/src/service_builder.rs
@@ -1,17 +1,18 @@
 #![allow(deprecated)]
 use crate::module::{
-    add_alert_rpc_methods, add_chain_rpc_methods, add_debug_rpc_methods,
-    add_experiment_rpc_methods, add_indexer_rpc_methods, add_integration_test_rpc_methods,
-    add_miner_rpc_methods, add_net_rpc_methods, add_pool_rpc_methods, add_rich_indexer_rpc_methods,
-    add_stats_rpc_methods, add_subscription_rpc_methods, AlertRpcImpl, ChainRpcImpl, DebugRpcImpl,
-    ExperimentRpcImpl, IndexerRpcImpl, IntegrationTestRpcImpl, MinerRpcImpl, NetRpcImpl,
-    PoolRpcImpl, RichIndexerRpcImpl, StatsRpcImpl, SubscriptionRpcImpl,
+    AlertRpcImpl, ChainRpcImpl, DebugRpcImpl, ExperimentRpcImpl, IndexerRpcImpl,
+    IntegrationTestRpcImpl, MinerRpcImpl, NetRpcImpl, PoolRpcImpl, RichIndexerRpcImpl,
+    StatsRpcImpl, SubscriptionRpcImpl, add_alert_rpc_methods, add_chain_rpc_methods,
+    add_debug_rpc_methods, add_experiment_rpc_methods, add_indexer_rpc_methods,
+    add_integration_test_rpc_methods, add_miner_rpc_methods, add_net_rpc_methods,
+    add_pool_rpc_methods, add_rich_indexer_rpc_methods, add_stats_rpc_methods,
+    add_subscription_rpc_methods,
 };
 use crate::{IoHandler, RPCError};
 use ckb_app_config::{DBConfig, IndexerConfig, RpcConfig};
 use ckb_chain::ChainController;
 use ckb_indexer::IndexerService;
-use ckb_indexer_sync::{new_secondary_db, PoolService};
+use ckb_indexer_sync::{PoolService, new_secondary_db};
 use ckb_network::NetworkController;
 use ckb_network_alert::{notifier::Notifier as AlertNotifier, verifier::Verifier as AlertVerifier};
 use ckb_pow::Pow;
diff --git a/rpc/src/tests/error.rs b/rpc/src/tests/error.rs
index 1ebacb93ac..732db9b157 100644
--- a/rpc/src/tests/error.rs
+++ b/rpc/src/tests/error.rs
@@ -2,7 +2,7 @@ use ckb_dao_utils::DaoError;
 use ckb_error::Error as CKBError;
 use ckb_tx_pool::error::Reject;
 use ckb_types::{
-    core::{error::OutPointError, FeeRate},
+    core::{FeeRate, error::OutPointError},
     packed::Byte32,
 };
 
@@ -22,15 +22,15 @@ fn test_submit_transaction_error() {
     let min_fee_rate = FeeRate::from_u64(500);
     let reject = Reject::LowFeeRate(min_fee_rate, 100, 50);
     assert_eq!(
-            "PoolRejectedTransactionByMinFeeRate: The min fee rate is 500 shannons/KW, requiring a transaction fee of at least 100 shannons, but the fee provided is only 50",
-            RPCError::from_submit_transaction_reject(&reject).message
-        );
+        "PoolRejectedTransactionByMinFeeRate: The min fee rate is 500 shannons/KW, requiring a transaction fee of at least 100 shannons, but the fee provided is only 50",
+        RPCError::from_submit_transaction_reject(&reject).message
+    );
 
     let reject = Reject::ExceededMaximumAncestorsCount;
     assert_eq!(
-            "PoolRejectedTransactionByMaxAncestorsCountLimit: Transaction exceeded maximum ancestors count limit; try later",
-            RPCError::from_submit_transaction_reject(&reject).message
-        );
+        "PoolRejectedTransactionByMaxAncestorsCountLimit: Transaction exceeded maximum ancestors count limit; try later",
+        RPCError::from_submit_transaction_reject(&reject).message
+    );
 
     let reject = Reject::Full(format!(
         "the fee_rate for this transaction is: {}",
@@ -43,9 +43,9 @@ fn test_submit_transaction_error() {
 
     let reject = Reject::Duplicated(Byte32::new([0; 32]));
     assert_eq!(
-            "PoolRejectedDuplicatedTransaction: Transaction(Byte32(0x0000000000000000000000000000000000000000000000000000000000000000)) already exists in transaction_pool",
-            RPCError::from_submit_transaction_reject(&reject).message
-        );
+        "PoolRejectedDuplicatedTransaction: Transaction(Byte32(0x0000000000000000000000000000000000000000000000000000000000000000)) already exists in transaction_pool",
+        RPCError::from_submit_transaction_reject(&reject).message
+    );
 
     let reject = Reject::Malformed("cellbase like".to_owned(), "".to_owned());
     assert_eq!(
@@ -64,7 +64,7 @@ fn test_submit_transaction_error() {
 fn test_out_point_error_from_ckb_error() {
     let err: CKBError = OutPointError::InvalidHeader(Byte32::new([0; 32])).into();
     assert_eq!(
-            "TransactionFailedToResolve: OutPoint(InvalidHeader(Byte32(0x0000000000000000000000000000000000000000000000000000000000000000)))",
-            RPCError::from_ckb_error(err).message
-        );
+        "TransactionFailedToResolve: OutPoint(InvalidHeader(Byte32(0x0000000000000000000000000000000000000000000000000000000000000000)))",
+        RPCError::from_ckb_error(err).message
+    );
 }
diff --git a/rpc/src/tests/examples.rs b/rpc/src/tests/examples.rs
index e66af3b62e..ee170b15ef 100644
--- a/rpc/src/tests/examples.rs
+++ b/rpc/src/tests/examples.rs
@@ -1,26 +1,26 @@
 use super::{
-    setup::{always_success_consensus, setup_rpc_test_suite},
     RpcTestRequest, RpcTestResponse, RpcTestSuite,
+    setup::{always_success_consensus, setup_rpc_test_suite},
 };
 use crate::tests::always_success_transaction;
 use ckb_test_chain_utils::always_success_cell;
 use pretty_assertions::assert_eq as pretty_assert_eq;
 use serde::de::DeserializeOwned;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 use std::cmp;
 use std::collections::BTreeSet;
 
-use std::fs::{read_dir, File};
+use std::fs::{File, read_dir};
 use std::hash;
 use std::io::{self, BufRead};
 use std::path::PathBuf;
 
 use ckb_types::{
-    core::{capacity_bytes, Capacity, TransactionBuilder, TransactionView},
+    H256,
+    core::{Capacity, TransactionBuilder, TransactionView, capacity_bytes},
     h256,
     packed::{CellDep, CellInput, CellOutputBuilder, OutPoint},
     prelude::*,
-    H256,
 };
 
 const TARGET_HEIGHT: u64 = 1024;
diff --git a/rpc/src/tests/mod.rs b/rpc/src/tests/mod.rs
index 59a2191b1b..ea3ba1e2b9 100644
--- a/rpc/src/tests/mod.rs
+++ b/rpc/src/tests/mod.rs
@@ -7,8 +7,8 @@ use ckb_store::ChainStore;
 use ckb_test_chain_utils::{always_success_cell, always_success_cellbase};
 use ckb_types::{
     core::{
-        cell::resolve_transaction, BlockBuilder, BlockView, HeaderView, TransactionBuilder,
-        TransactionView,
+        BlockBuilder, BlockView, HeaderView, TransactionBuilder, TransactionView,
+        cell::resolve_transaction,
     },
     packed::{CellInput, OutPoint},
     prelude::*,
diff --git a/rpc/src/tests/module/miner.rs b/rpc/src/tests/module/miner.rs
index 42f9bbb325..7e1612150e 100644
--- a/rpc/src/tests/module/miner.rs
+++ b/rpc/src/tests/module/miner.rs
@@ -1,8 +1,8 @@
-use crate::tests::{always_success_transaction, setup, RpcTestRequest};
+use crate::tests::{RpcTestRequest, always_success_transaction, setup};
 use ckb_store::ChainStore;
 use ckb_test_chain_utils::{always_success_cell, always_success_consensus};
 use ckb_types::{
-    core::{capacity_bytes, Capacity, TransactionBuilder},
+    core::{Capacity, TransactionBuilder, capacity_bytes},
     packed::{CellDep, CellInput, CellOutputBuilder, OutPoint},
     prelude::*,
 };
diff --git a/rpc/src/tests/module/pool.rs b/rpc/src/tests/module/pool.rs
index f96bb1f24b..e0bb034ef9 100644
--- a/rpc/src/tests/module/pool.rs
+++ b/rpc/src/tests/module/pool.rs
@@ -9,7 +9,7 @@ use serde_json::json;
 
 use crate::{
     module::pool::WellKnownScriptsOnlyValidator,
-    tests::{always_success_transaction, setup, RpcTestRequest},
+    tests::{RpcTestRequest, always_success_transaction, setup},
 };
 
 #[test]
@@ -175,10 +175,12 @@ fn test_send_transaction_exceeded_maximum_ancestors_count() {
         if i != 2000 {
             assert_eq!(response.error.to_string(), "null".to_string());
         } else {
-            assert!(response
-                .error
-                .to_string()
-                .contains("ExceededMaximumAncestorsCount"));
+            assert!(
+                response
+                    .error
+                    .to_string()
+                    .contains("ExceededMaximumAncestorsCount")
+            );
         }
         parent_tx_hash = tx.hash();
     }
diff --git a/rpc/src/tests/module/test.rs b/rpc/src/tests/module/test.rs
index 202139a349..d0909553ca 100644
--- a/rpc/src/tests/module/test.rs
+++ b/rpc/src/tests/module/test.rs
@@ -8,7 +8,7 @@ use ckb_types::{
     utilities::DIFF_TWO,
 };
 
-use crate::tests::{setup, RpcTestRequest, RpcTestSuite};
+use crate::tests::{RpcTestRequest, RpcTestSuite, setup};
 
 const GENESIS_EPOCH_LENGTH: u64 = 30;
 
diff --git a/rpc/src/tests/setup.rs b/rpc/src/tests/setup.rs
index 4afea1fa6d..4614487bfa 100644
--- a/rpc/src/tests/setup.rs
+++ b/rpc/src/tests/setup.rs
@@ -1,6 +1,6 @@
 use crate::{
-    tests::{always_success_transaction, next_block},
     RpcServer, ServiceBuilder,
+    tests::{always_success_transaction, next_block},
 };
 use ckb_app_config::{
     BlockAssemblerConfig, NetworkAlertConfig, NetworkConfig, RpcConfig, RpcModule,
@@ -9,7 +9,7 @@ use ckb_chain::start_chain_services;
 use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_chain_spec::versionbits::{ActiveMode, Deployment, DeploymentPos};
 use ckb_dao_utils::genesis_dao_data;
-use ckb_network::{network::TransportType, Flags, NetworkService, NetworkState};
+use ckb_network::{Flags, NetworkService, NetworkState, network::TransportType};
 use ckb_network_alert::alert_relayer::AlertRelayer;
 use ckb_notify::NotifyService;
 use ckb_shared::SharedBuilder;
diff --git a/rpc/src/util/fee_rate.rs b/rpc/src/util/fee_rate.rs
index fbb1086001..f06a89b3a6 100644
--- a/rpc/src/util/fee_rate.rs
+++ b/rpc/src/util/fee_rate.rs
@@ -1,7 +1,7 @@
 use ckb_jsonrpc_types::FeeRateStatistics;
 use ckb_shared::Snapshot;
 use ckb_store::ChainStore;
-use ckb_types::core::{tx_pool::get_transaction_weight, BlockExt, BlockNumber, FeeRate};
+use ckb_types::core::{BlockExt, BlockNumber, FeeRate, tx_pool::get_transaction_weight};
 
 const DEFAULT_TARGET: u64 = 21;
 const MIN_TARGET: u64 = 1;
diff --git a/script/src/error.rs b/script/src/error.rs
index 9d55d7a67f..4a5f2077cf 100644
--- a/script/src/error.rs
+++ b/script/src/error.rs
@@ -1,5 +1,5 @@
 use crate::types::{ScriptGroup, ScriptGroupType};
-use ckb_error::{prelude::*, Error, ErrorKind, InternalErrorKind};
+use ckb_error::{Error, ErrorKind, InternalErrorKind, prelude::*};
 use ckb_types::core::{Cycle, ScriptHashType};
 use ckb_types::packed::{Byte32, Script};
 use ckb_vm::Error as VMInternalError;
@@ -25,7 +25,9 @@ pub enum ScriptError {
     MultipleMatches,
 
     /// Non-zero exit code returns by script
-    #[error("ValidationFailure: see error code {1} on page https://nervosnetwork.github.io/ckb-script-error-codes/{0}.html#{1}")]
+    #[error(
+        "ValidationFailure: see error code {1} on page https://nervosnetwork.github.io/ckb-script-error-codes/{0}.html#{1}"
+    )]
     ValidationFailure(String, i8),
 
     /// Known bugs are detected in transaction script outputs
diff --git a/script/src/lib.rs b/script/src/lib.rs
index c50468a7c5..b56daf7ca7 100644
--- a/script/src/lib.rs
+++ b/script/src/lib.rs
@@ -9,7 +9,7 @@ mod verify;
 mod verify_env;
 
 pub use crate::error::{ScriptError, TransactionScriptError};
-pub use crate::scheduler::{Scheduler, ROOT_VM_ID};
+pub use crate::scheduler::{ROOT_VM_ID, Scheduler};
 pub use crate::syscalls::generator::generate_ckb_syscalls;
 pub use crate::types::{
     ChunkCommand, CoreMachine, DataLocation, DataPieceId, RunMode, ScriptGroup, ScriptGroupType,
diff --git a/script/src/scheduler.rs b/script/src/scheduler.rs
index 807b7ce5b2..c005f6f9db 100644
--- a/script/src/scheduler.rs
+++ b/script/src/scheduler.rs
@@ -1,18 +1,19 @@
 use crate::cost_model::transferred_byte_cycles;
 use crate::syscalls::{
-    generator::generate_ckb_syscalls, EXEC_LOAD_ELF_V2_CYCLES_BASE, INVALID_FD, MAX_FDS_CREATED,
-    MAX_VMS_SPAWNED, OTHER_END_CLOSED, SPAWN_EXTRA_CYCLES_BASE, SUCCESS, WAIT_FAILURE,
+    EXEC_LOAD_ELF_V2_CYCLES_BASE, INVALID_FD, MAX_FDS_CREATED, MAX_VMS_SPAWNED, OTHER_END_CLOSED,
+    SPAWN_EXTRA_CYCLES_BASE, SUCCESS, WAIT_FAILURE, generator::generate_ckb_syscalls,
 };
 
 use crate::types::{
-    CoreMachineType, DataLocation, DataPieceId, DebugContext, Fd, FdArgs, FullSuspendedState,
-    Machine, Message, ReadState, RunMode, SgData, VmArgs, VmContext, VmId, VmState, WriteState,
-    FIRST_FD_SLOT, FIRST_VM_ID,
+    CoreMachineType, DataLocation, DataPieceId, DebugContext, FIRST_FD_SLOT, FIRST_VM_ID, Fd,
+    FdArgs, FullSuspendedState, Machine, Message, ReadState, RunMode, SgData, VmArgs, VmContext,
+    VmId, VmState, WriteState,
 };
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_types::core::Cycle;
 use ckb_vm::snapshot2::Snapshot2Context;
 use ckb_vm::{
+    Error, FlattenedArgsReader, Register,
     bytes::Bytes,
     cost_model::estimate_cycles,
     elf::parse_elf,
@@ -20,12 +21,11 @@ use ckb_vm::{
     memory::Memory,
     registers::A0,
     snapshot2::Snapshot2,
-    Error, FlattenedArgsReader, Register,
 };
 use std::collections::{BTreeMap, HashMap};
 use std::sync::{
-    atomic::{AtomicU64, Ordering},
     Arc, Mutex,
+    atomic::{AtomicU64, Ordering},
 };
 
 /// Root process's id.
diff --git a/script/src/syscalls/close.rs b/script/src/syscalls/close.rs
index 536465b9da..01864b4cbe 100644
--- a/script/src/syscalls/close.rs
+++ b/script/src/syscalls/close.rs
@@ -2,8 +2,8 @@ use crate::syscalls::{CLOSE, SPAWN_YIELD_CYCLES_BASE};
 use crate::types::{Fd, Message, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
-    registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A7},
 };
 use std::sync::{Arc, Mutex};
 
diff --git a/script/src/syscalls/current_cycles.rs b/script/src/syscalls/current_cycles.rs
index 14e13da807..d9794c70bb 100644
--- a/script/src/syscalls/current_cycles.rs
+++ b/script/src/syscalls/current_cycles.rs
@@ -1,12 +1,12 @@
 use crate::{syscalls::CURRENT_CYCLES, types::VmContext};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
-    registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A7},
 };
 use std::sync::{
-    atomic::{AtomicU64, Ordering},
     Arc,
+    atomic::{AtomicU64, Ordering},
 };
 
 #[derive(Debug, Default)]
diff --git a/script/src/syscalls/debugger.rs b/script/src/syscalls/debugger.rs
index 75d2771638..4066872413 100644
--- a/script/src/syscalls/debugger.rs
+++ b/script/src/syscalls/debugger.rs
@@ -3,8 +3,8 @@ use crate::types::{
 };
 use crate::{cost_model::transferred_byte_cycles, syscalls::DEBUG_PRINT_SYSCALL_NUMBER};
 use ckb_vm::{
-    registers::{A0, A7},
     Error as VMError, Memory, Register, SupportMachine, Syscalls,
+    registers::{A0, A7},
 };
 use std::sync::Arc;
 
diff --git a/script/src/syscalls/exec.rs b/script/src/syscalls/exec.rs
index ac1ce8cb70..8b9cd6593d 100644
--- a/script/src/syscalls/exec.rs
+++ b/script/src/syscalls/exec.rs
@@ -1,6 +1,6 @@
 use crate::cost_model::transferred_byte_cycles;
 use crate::syscalls::{
-    Place, Source, SourceEntry, EXEC, INDEX_OUT_OF_BOUND, MAX_ARGV_LENGTH, SLICE_OUT_OF_BOUND,
+    EXEC, INDEX_OUT_OF_BOUND, MAX_ARGV_LENGTH, Place, SLICE_OUT_OF_BOUND, Source, SourceEntry,
     WRONG_FORMAT,
 };
 use crate::types::SgData;
@@ -8,13 +8,13 @@ use ckb_traits::CellDataProvider;
 use ckb_types::core::cell::CellMeta;
 use ckb_types::core::error::ARGV_TOO_LONG_TEXT;
 use ckb_types::packed::{Bytes as PackedBytes, BytesVec};
-use ckb_vm::memory::load_c_string_byte_by_byte;
 use ckb_vm::Memory;
+use ckb_vm::memory::load_c_string_byte_by_byte;
+use ckb_vm::{DEFAULT_STACK_SIZE, RISCV_MAX_MEMORY};
 use ckb_vm::{
-    registers::{A0, A1, A2, A3, A4, A5, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A1, A2, A3, A4, A5, A7},
 };
-use ckb_vm::{DEFAULT_STACK_SIZE, RISCV_MAX_MEMORY};
 
 #[derive(Debug)]
 pub struct Exec<DL> {
diff --git a/script/src/syscalls/exec_v2.rs b/script/src/syscalls/exec_v2.rs
index 5f08ab39a9..3f3bc61655 100644
--- a/script/src/syscalls/exec_v2.rs
+++ b/script/src/syscalls/exec_v2.rs
@@ -2,8 +2,8 @@ use crate::syscalls::{EXEC, INDEX_OUT_OF_BOUND};
 use crate::types::{DataLocation, DataPieceId, ExecV2Args, Message, VmContext, VmId};
 use ckb_traits::CellDataProvider;
 use ckb_vm::{
-    registers::{A0, A1, A2, A3, A4, A5, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A1, A2, A3, A4, A5, A7},
 };
 use std::sync::{Arc, Mutex};
 
diff --git a/script/src/syscalls/inherited_fd.rs b/script/src/syscalls/inherited_fd.rs
index 510b82969c..d29ea5f07a 100644
--- a/script/src/syscalls/inherited_fd.rs
+++ b/script/src/syscalls/inherited_fd.rs
@@ -2,8 +2,8 @@ use crate::syscalls::{INHERITED_FD, SPAWN_YIELD_CYCLES_BASE};
 use crate::types::{Fd, FdArgs, Message, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
-    registers::{A0, A1, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A1, A7},
 };
 use std::sync::{Arc, Mutex};
 
diff --git a/script/src/syscalls/load_block_extension.rs b/script/src/syscalls/load_block_extension.rs
index d38cf4b8cc..9b6bc20bca 100644
--- a/script/src/syscalls/load_block_extension.rs
+++ b/script/src/syscalls/load_block_extension.rs
@@ -1,8 +1,8 @@
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{
-        utils::store_data, Source, SourceEntry, INDEX_OUT_OF_BOUND, ITEM_MISSING,
-        LOAD_BLOCK_EXTENSION, SUCCESS,
+        INDEX_OUT_OF_BOUND, ITEM_MISSING, LOAD_BLOCK_EXTENSION, SUCCESS, Source, SourceEntry,
+        utils::store_data,
     },
     types::SgData,
 };
@@ -12,8 +12,8 @@ use ckb_types::{
     packed::{self, Byte32Vec},
 };
 use ckb_vm::{
-    registers::{A0, A3, A4, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A3, A4, A7},
 };
 
 #[derive(Debug)]
diff --git a/script/src/syscalls/load_cell.rs b/script/src/syscalls/load_cell.rs
index 3c6212b1bd..48ab1d89e1 100644
--- a/script/src/syscalls/load_cell.rs
+++ b/script/src/syscalls/load_cell.rs
@@ -1,21 +1,21 @@
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{
-        utils::store_data, CellField, Source, SourceEntry, INDEX_OUT_OF_BOUND, ITEM_MISSING,
-        LOAD_CELL_BY_FIELD_SYSCALL_NUMBER, LOAD_CELL_SYSCALL_NUMBER, SUCCESS,
+        CellField, INDEX_OUT_OF_BOUND, ITEM_MISSING, LOAD_CELL_BY_FIELD_SYSCALL_NUMBER,
+        LOAD_CELL_SYSCALL_NUMBER, SUCCESS, Source, SourceEntry, utils::store_data,
     },
     types::{SgData, TxInfo},
 };
 use byteorder::{LittleEndian, WriteBytesExt};
 use ckb_traits::CellDataProvider;
 use ckb_types::{
-    core::{cell::CellMeta, Capacity},
+    core::{Capacity, cell::CellMeta},
     packed::CellOutput,
     prelude::*,
 };
 use ckb_vm::{
-    registers::{A0, A3, A4, A5, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A3, A4, A5, A7},
 };
 
 pub struct LoadCell<DL> {
diff --git a/script/src/syscalls/load_cell_data.rs b/script/src/syscalls/load_cell_data.rs
index 3aa6b24645..61134d8202 100644
--- a/script/src/syscalls/load_cell_data.rs
+++ b/script/src/syscalls/load_cell_data.rs
@@ -2,17 +2,16 @@ use crate::types::{DataPieceId, SgData, VmContext};
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{
-        Source, INDEX_OUT_OF_BOUND, LOAD_CELL_DATA_AS_CODE_SYSCALL_NUMBER,
-        LOAD_CELL_DATA_SYSCALL_NUMBER, SLICE_OUT_OF_BOUND, SOURCE_ENTRY_MASK, SOURCE_GROUP_FLAG,
-        SUCCESS,
+        INDEX_OUT_OF_BOUND, LOAD_CELL_DATA_AS_CODE_SYSCALL_NUMBER, LOAD_CELL_DATA_SYSCALL_NUMBER,
+        SLICE_OUT_OF_BOUND, SOURCE_ENTRY_MASK, SOURCE_GROUP_FLAG, SUCCESS, Source,
     },
 };
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
-    memory::{Memory, FLAG_EXECUTABLE, FLAG_FREEZED},
+    Bytes, Error as VMError, Register, SupportMachine, Syscalls,
+    memory::{FLAG_EXECUTABLE, FLAG_FREEZED, Memory},
     registers::{A0, A1, A2, A3, A4, A5, A7},
     snapshot2::Snapshot2Context,
-    Bytes, Error as VMError, Register, SupportMachine, Syscalls,
 };
 use std::sync::{Arc, Mutex};
 
diff --git a/script/src/syscalls/load_header.rs b/script/src/syscalls/load_header.rs
index 10629c844c..05fd93e0be 100644
--- a/script/src/syscalls/load_header.rs
+++ b/script/src/syscalls/load_header.rs
@@ -1,21 +1,21 @@
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{
+        HeaderField, INDEX_OUT_OF_BOUND, ITEM_MISSING, LOAD_HEADER_BY_FIELD_SYSCALL_NUMBER,
+        LOAD_HEADER_SYSCALL_NUMBER, SUCCESS, Source, SourceEntry,
         utils::{store_data, store_u64},
-        HeaderField, Source, SourceEntry, INDEX_OUT_OF_BOUND, ITEM_MISSING,
-        LOAD_HEADER_BY_FIELD_SYSCALL_NUMBER, LOAD_HEADER_SYSCALL_NUMBER, SUCCESS,
     },
     types::SgData,
 };
 use ckb_traits::HeaderProvider;
 use ckb_types::{
-    core::{cell::CellMeta, HeaderView},
+    core::{HeaderView, cell::CellMeta},
     packed::Byte32Vec,
     prelude::*,
 };
 use ckb_vm::{
-    registers::{A0, A3, A4, A5, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A3, A4, A5, A7},
 };
 #[derive(Debug)]
 pub struct LoadHeader<DL> {
diff --git a/script/src/syscalls/load_input.rs b/script/src/syscalls/load_input.rs
index 2d1f415f32..5fa173a838 100644
--- a/script/src/syscalls/load_input.rs
+++ b/script/src/syscalls/load_input.rs
@@ -1,8 +1,8 @@
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{
-        utils::store_data, InputField, Source, SourceEntry, INDEX_OUT_OF_BOUND,
-        LOAD_INPUT_BY_FIELD_SYSCALL_NUMBER, LOAD_INPUT_SYSCALL_NUMBER, SUCCESS,
+        INDEX_OUT_OF_BOUND, InputField, LOAD_INPUT_BY_FIELD_SYSCALL_NUMBER,
+        LOAD_INPUT_SYSCALL_NUMBER, SUCCESS, Source, SourceEntry, utils::store_data,
     },
     types::SgData,
 };
@@ -12,8 +12,8 @@ use ckb_types::{
     prelude::*,
 };
 use ckb_vm::{
-    registers::{A0, A3, A4, A5, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A3, A4, A5, A7},
 };
 
 #[derive(Debug)]
diff --git a/script/src/syscalls/load_script.rs b/script/src/syscalls/load_script.rs
index 545e8e7492..7215adaca5 100644
--- a/script/src/syscalls/load_script.rs
+++ b/script/src/syscalls/load_script.rs
@@ -1,12 +1,12 @@
 use crate::{
     cost_model::transferred_byte_cycles,
-    syscalls::{utils::store_data, LOAD_SCRIPT_SYSCALL_NUMBER, SUCCESS},
+    syscalls::{LOAD_SCRIPT_SYSCALL_NUMBER, SUCCESS, utils::store_data},
     types::{SgData, SgInfo},
 };
 use ckb_types::prelude::*;
 use ckb_vm::{
-    registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A7},
 };
 use std::sync::Arc;
 
diff --git a/script/src/syscalls/load_script_hash.rs b/script/src/syscalls/load_script_hash.rs
index 0fe93e2f30..5057f7f658 100644
--- a/script/src/syscalls/load_script_hash.rs
+++ b/script/src/syscalls/load_script_hash.rs
@@ -1,11 +1,11 @@
 use crate::{
     cost_model::transferred_byte_cycles,
-    syscalls::{utils::store_data, LOAD_SCRIPT_HASH_SYSCALL_NUMBER, SUCCESS},
+    syscalls::{LOAD_SCRIPT_HASH_SYSCALL_NUMBER, SUCCESS, utils::store_data},
     types::{SgData, SgInfo},
 };
 use ckb_vm::{
-    registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A7},
 };
 use std::sync::Arc;
 
diff --git a/script/src/syscalls/load_tx.rs b/script/src/syscalls/load_tx.rs
index d0db1a3ce0..72f2189e29 100644
--- a/script/src/syscalls/load_tx.rs
+++ b/script/src/syscalls/load_tx.rs
@@ -1,14 +1,14 @@
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{
-        utils::store_data, LOAD_TRANSACTION_SYSCALL_NUMBER, LOAD_TX_HASH_SYSCALL_NUMBER, SUCCESS,
+        LOAD_TRANSACTION_SYSCALL_NUMBER, LOAD_TX_HASH_SYSCALL_NUMBER, SUCCESS, utils::store_data,
     },
     types::SgData,
 };
 use ckb_types::{core::cell::ResolvedTransaction, prelude::*};
 use ckb_vm::{
-    registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A7},
 };
 use std::sync::Arc;
 
diff --git a/script/src/syscalls/load_witness.rs b/script/src/syscalls/load_witness.rs
index 3ff4863199..aee7f8d475 100644
--- a/script/src/syscalls/load_witness.rs
+++ b/script/src/syscalls/load_witness.rs
@@ -1,15 +1,15 @@
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{
-        utils::store_data, Source, SourceEntry, INDEX_OUT_OF_BOUND, LOAD_WITNESS_SYSCALL_NUMBER,
-        SUCCESS,
+        INDEX_OUT_OF_BOUND, LOAD_WITNESS_SYSCALL_NUMBER, SUCCESS, Source, SourceEntry,
+        utils::store_data,
     },
     types::SgData,
 };
 use ckb_types::packed::{Bytes, BytesVec};
 use ckb_vm::{
-    registers::{A0, A3, A4, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A3, A4, A7},
 };
 
 #[derive(Debug)]
diff --git a/script/src/syscalls/pause.rs b/script/src/syscalls/pause.rs
index 1de3401bdc..a44f4dbada 100644
--- a/script/src/syscalls/pause.rs
+++ b/script/src/syscalls/pause.rs
@@ -1,8 +1,8 @@
 use crate::syscalls::DEBUG_PAUSE;
-use ckb_vm::{registers::A7, Error as VMError, Register, SupportMachine, Syscalls};
+use ckb_vm::{Error as VMError, Register, SupportMachine, Syscalls, registers::A7};
 use std::sync::{
-    atomic::{AtomicBool, Ordering},
     Arc,
+    atomic::{AtomicBool, Ordering},
 };
 
 #[derive(Debug)]
diff --git a/script/src/syscalls/pipe.rs b/script/src/syscalls/pipe.rs
index db7004b548..d6b20285b6 100644
--- a/script/src/syscalls/pipe.rs
+++ b/script/src/syscalls/pipe.rs
@@ -2,8 +2,8 @@ use crate::syscalls::{PIPE, SPAWN_YIELD_CYCLES_BASE};
 use crate::types::{Message, PipeArgs, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
-    registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A7},
 };
 use std::sync::{Arc, Mutex};
 
diff --git a/script/src/syscalls/process_id.rs b/script/src/syscalls/process_id.rs
index 37b4df21e3..ed51c579fc 100644
--- a/script/src/syscalls/process_id.rs
+++ b/script/src/syscalls/process_id.rs
@@ -1,8 +1,8 @@
 use crate::syscalls::PROCESS_ID;
 use crate::types::VmId;
 use ckb_vm::{
-    registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A7},
 };
 
 #[derive(Debug, Default)]
diff --git a/script/src/syscalls/read.rs b/script/src/syscalls/read.rs
index 7c96c7125b..aa90a977e0 100644
--- a/script/src/syscalls/read.rs
+++ b/script/src/syscalls/read.rs
@@ -2,8 +2,8 @@ use crate::syscalls::{INVALID_FD, READ, SPAWN_YIELD_CYCLES_BASE};
 use crate::types::{Fd, FdArgs, Message, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
-    registers::{A0, A1, A2, A7},
     Error as VMError, Memory, Register, SupportMachine, Syscalls,
+    registers::{A0, A1, A2, A7},
 };
 use std::sync::{Arc, Mutex};
 
diff --git a/script/src/syscalls/spawn.rs b/script/src/syscalls/spawn.rs
index a90ed3082a..6aba859bb0 100644
--- a/script/src/syscalls/spawn.rs
+++ b/script/src/syscalls/spawn.rs
@@ -1,16 +1,16 @@
 use crate::syscalls::{
-    Source, INDEX_OUT_OF_BOUND, SLICE_OUT_OF_BOUND, SOURCE_ENTRY_MASK, SOURCE_GROUP_FLAG, SPAWN,
-    SPAWN_EXTRA_CYCLES_BASE, SPAWN_YIELD_CYCLES_BASE,
+    INDEX_OUT_OF_BOUND, SLICE_OUT_OF_BOUND, SOURCE_ENTRY_MASK, SOURCE_GROUP_FLAG, SPAWN,
+    SPAWN_EXTRA_CYCLES_BASE, SPAWN_YIELD_CYCLES_BASE, Source,
 };
 use crate::types::{DataLocation, DataPieceId, Fd, Message, SgData, SpawnArgs, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
+    Error as VMError, Register,
     machine::SupportMachine,
     memory::Memory,
     registers::{A0, A1, A2, A3, A4, A7},
     snapshot2::Snapshot2Context,
     syscalls::Syscalls,
-    Error as VMError, Register,
 };
 use std::sync::{Arc, Mutex};
 
diff --git a/script/src/syscalls/tests/utils.rs b/script/src/syscalls/tests/utils.rs
index 4f2da451e9..aea110b5d9 100644
--- a/script/src/syscalls/tests/utils.rs
+++ b/script/src/syscalls/tests/utils.rs
@@ -9,8 +9,8 @@ use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_types::{
     bytes::Bytes,
     core::{
-        cell::{CellMeta, ResolvedTransaction},
         Capacity, HeaderBuilder, HeaderView,
+        cell::{CellMeta, ResolvedTransaction},
     },
     packed::{self, Byte32, CellOutput, OutPoint, Script},
     prelude::*,
diff --git a/script/src/syscalls/tests/vm_latest/syscalls_1.rs b/script/src/syscalls/tests/vm_latest/syscalls_1.rs
index 98f7843dcc..afd7b97113 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_1.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_1.rs
@@ -2,20 +2,20 @@ use crate::types::VmContext;
 use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
 use ckb_hash::blake2b_256;
 use ckb_types::{
+    H256,
     bytes::Bytes,
     core::{
-        cell::{CellMeta, ResolvedTransaction},
         Capacity, EpochNumberWithFraction, HeaderBuilder, ScriptHashType, TransactionBuilder,
         TransactionInfo,
+        cell::{CellMeta, ResolvedTransaction},
     },
     packed::{CellInput, CellOutput, OutPoint, Script, ScriptBuilder},
     prelude::*,
-    H256,
 };
 use ckb_vm::{
+    CoreMachine, Error as VMError, Memory, RISCV_PAGESIZE, Syscalls,
     memory::{FLAG_DIRTY, FLAG_EXECUTABLE, FLAG_FREEZED, FLAG_WRITABLE},
     registers::{A0, A1, A2, A3, A4, A5, A7},
-    CoreMachine, Error as VMError, Memory, Syscalls, RISCV_PAGESIZE,
 };
 use proptest::{collection::size_range, prelude::*};
 use std::collections::HashMap;
@@ -36,10 +36,12 @@ fn _test_load_cell_not_exist(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A4, u64::from(Source::Transaction(SourceEntry::Input))); //source: 1 input
     machine.set_register(A7, LOAD_CELL_SYSCALL_NUMBER); // syscall number
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(data.len() as u64))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(data.len() as u64))
+            .is_ok()
+    );
 
     let output_cell_data = Bytes::from(data.to_owned());
     let output = build_cell_meta(100, output_cell_data);
@@ -103,10 +105,12 @@ fn _test_load_cell_all(data: &[u8]) -> Result<(), TestCaseError> {
     let output_correct_data = output.cell_output.as_slice();
 
     // test input
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(input_correct_data.len() as u64))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(input_correct_data.len() as u64))
+            .is_ok()
+    );
 
     prop_assert!(load_cell.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -130,10 +134,12 @@ fn _test_load_cell_all(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A0, addr); // addr
     machine.set_register(A1, size_addr); // size_addr
     machine.set_register(A4, u64::from(Source::Transaction(SourceEntry::Output))); //source: 2 output
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(output_correct_data.len() as u64 + 10))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(output_correct_data.len() as u64 + 10))
+            .is_ok()
+    );
 
     prop_assert!(load_cell.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -193,10 +199,12 @@ fn _test_load_cell_from_group(data: &[u8], source: SourceEntry) -> Result<(), Te
 
     if source == SourceEntry::Input {
         // test input
-        prop_assert!(machine
-            .memory_mut()
-            .store64(&size_addr, &(input_correct_data.len() as u64))
-            .is_ok());
+        prop_assert!(
+            machine
+                .memory_mut()
+                .store64(&size_addr, &(input_correct_data.len() as u64))
+                .is_ok()
+        );
 
         prop_assert!(load_cell.ecall(&mut machine).is_ok());
         prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -213,10 +221,12 @@ fn _test_load_cell_from_group(data: &[u8], source: SourceEntry) -> Result<(), Te
             );
         }
     } else {
-        prop_assert!(machine
-            .memory_mut()
-            .store64(&size_addr, &(output_correct_data.len() as u64 + 10))
-            .is_ok());
+        prop_assert!(
+            machine
+                .memory_mut()
+                .store64(&size_addr, &(output_correct_data.len() as u64 + 10))
+                .is_ok()
+        );
 
         prop_assert!(load_cell.ecall(&mut machine).is_ok());
         prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -384,10 +394,12 @@ fn _test_load_cell_partial(data: &[u8], offset: u64) -> Result<(), TestCaseError
 
     let input_correct_data = input_cell.cell_output.as_slice();
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(input_correct_data.len() as u64))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(input_correct_data.len() as u64))
+            .is_ok()
+    );
 
     prop_assert!(load_cell.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -680,10 +692,12 @@ fn _test_load_header(
 
     let mut load_header = LoadHeader::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(header_correct_data.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(header_correct_data.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_header.ecall(&mut machine).is_ok());
 
@@ -797,10 +811,12 @@ fn _test_load_header_by_field(data: &[u8], field: HeaderField) -> Result<(), Tes
 
     let mut load_header = LoadHeader::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(correct_data.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(correct_data.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_header.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -849,10 +865,12 @@ fn _test_load_tx_hash(data: &[u8]) -> Result<(), TestCaseError> {
 
     let mut load_tx = LoadTx::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(hash_len + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(hash_len + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_tx.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -902,10 +920,12 @@ fn _test_load_tx(data: &[u8]) -> Result<(), TestCaseError> {
 
     let mut load_tx = LoadTx::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(tx_len + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(tx_len + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_tx.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -1097,10 +1117,12 @@ fn _test_load_input_lock_script(data: &[u8]) -> Result<(), TestCaseError> {
 
     let mut load_cell = LoadCell::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(lock.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(lock.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_cell.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -1162,10 +1184,12 @@ fn _test_load_input_type_script(data: &[u8]) -> Result<(), TestCaseError> {
 
     let mut load_cell = LoadCell::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(type_.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(type_.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_cell.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -1229,10 +1253,12 @@ fn _test_load_input_type_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
 
     let mut load_cell = LoadCell::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(hash.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(hash.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_cell.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -1285,10 +1311,12 @@ fn _test_load_witness(data: &[u8], source: SourceEntry) -> Result<(), TestCaseEr
 
     let mut load_witness = LoadWitness::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(witness_correct_data.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(witness_correct_data.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_witness.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -1350,10 +1378,12 @@ fn _test_load_group_witness(data: &[u8], source: SourceEntry) -> Result<(), Test
 
     let mut load_witness = LoadWitness::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(witness_correct_data.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(witness_correct_data.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_witness.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -1411,10 +1441,12 @@ fn _test_load_script(data: &[u8]) -> Result<(), TestCaseError> {
 
     let mut load_script = LoadScript::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(script_correct_data.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(script_correct_data.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_script.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
@@ -1659,14 +1691,18 @@ fn _test_load_cell_data_on_freezed_memory(data: &[u8]) -> Result<(), TestCaseErr
     let addr_size = 4096;
     let size_addr = 100;
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(data.len() as u64))
-        .is_ok());
-    prop_assert!(machine
-        .memory_mut()
-        .init_pages(addr, addr_size, FLAG_EXECUTABLE | FLAG_FREEZED, None, 0)
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(data.len() as u64))
+            .is_ok()
+    );
+    prop_assert!(
+        machine
+            .memory_mut()
+            .init_pages(addr, addr_size, FLAG_EXECUTABLE | FLAG_FREEZED, None, 0)
+            .is_ok()
+    );
 
     machine.set_register(A0, addr); // addr
     machine.set_register(A1, size_addr); // size
@@ -1704,10 +1740,12 @@ fn _test_load_cell_data_as_code_on_freezed_memory(data: &[u8]) -> Result<(), Tes
     let addr = 8192;
     let addr_size = 4096;
 
-    prop_assert!(machine
-        .memory_mut()
-        .init_pages(addr, addr_size, FLAG_EXECUTABLE | FLAG_FREEZED, None, 0)
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .init_pages(addr, addr_size, FLAG_EXECUTABLE | FLAG_FREEZED, None, 0)
+            .is_ok()
+    );
 
     machine.set_register(A0, addr); // addr
     machine.set_register(A1, addr_size); // size
@@ -1946,10 +1984,12 @@ fn _test_load_input(
         input.as_slice()
     };
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(expect.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(expect.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_input.ecall(&mut machine).is_ok());
 
diff --git a/script/src/syscalls/tests/vm_latest/syscalls_2.rs b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
index 0f40dc1e51..5e1d778b20 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_2.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
@@ -2,15 +2,15 @@ use crate::{syscalls::tests::utils::*, types::VmContext};
 use ckb_types::{
     bytes::Bytes,
     core::{
-        cell::{CellMeta, ResolvedTransaction},
         HeaderBuilder, TransactionBuilder, TransactionInfo,
+        cell::{CellMeta, ResolvedTransaction},
     },
     packed::{CellOutput, OutPoint},
     prelude::*,
 };
 use ckb_vm::{
-    registers::{A0, A1, A2, A3, A4, A5, A7},
     CoreMachine, Memory, SupportMachine, Syscalls,
+    registers::{A0, A1, A2, A3, A4, A5, A7},
 };
 use proptest::{collection::size_range, prelude::*};
 use std::collections::HashMap;
@@ -124,10 +124,12 @@ fn _test_load_extension(
 
     let mut load_block_extension = LoadBlockExtension::new(&sg_data);
 
-    prop_assert!(machine
-        .memory_mut()
-        .store64(&size_addr, &(data.len() as u64 + 20))
-        .is_ok());
+    prop_assert!(
+        machine
+            .memory_mut()
+            .store64(&size_addr, &(data.len() as u64 + 20))
+            .is_ok()
+    );
 
     prop_assert!(load_block_extension.ecall(&mut machine).is_ok());
 
diff --git a/script/src/syscalls/utils.rs b/script/src/syscalls/utils.rs
index 8729e82759..788e0da1e0 100644
--- a/script/src/syscalls/utils.rs
+++ b/script/src/syscalls/utils.rs
@@ -1,7 +1,7 @@
 use byteorder::{ByteOrder, LittleEndian};
 use ckb_vm::{
-    registers::{A0, A1, A2},
     Error as VMError, Memory, Register, SupportMachine,
+    registers::{A0, A1, A2},
 };
 use std::cmp;
 
diff --git a/script/src/syscalls/vm_version.rs b/script/src/syscalls/vm_version.rs
index 1884c0fa69..99584a13e4 100644
--- a/script/src/syscalls/vm_version.rs
+++ b/script/src/syscalls/vm_version.rs
@@ -1,7 +1,7 @@
 use crate::syscalls::VM_VERSION;
 use ckb_vm::{
-    registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A7},
 };
 
 #[derive(Debug, Default)]
diff --git a/script/src/syscalls/wait.rs b/script/src/syscalls/wait.rs
index 11ae3693e3..e3dc00c413 100644
--- a/script/src/syscalls/wait.rs
+++ b/script/src/syscalls/wait.rs
@@ -2,8 +2,8 @@ use crate::syscalls::{SPAWN_YIELD_CYCLES_BASE, WAIT};
 use crate::types::{Message, VmContext, VmId, WaitArgs};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
-    registers::{A0, A1, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
+    registers::{A0, A1, A7},
 };
 use std::sync::{Arc, Mutex};
 
diff --git a/script/src/syscalls/write.rs b/script/src/syscalls/write.rs
index 2784abbeb4..57ede32ca1 100644
--- a/script/src/syscalls/write.rs
+++ b/script/src/syscalls/write.rs
@@ -2,8 +2,8 @@ use crate::syscalls::{INVALID_FD, SPAWN_YIELD_CYCLES_BASE, WRITE};
 use crate::types::{Fd, FdArgs, Message, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
-    registers::{A0, A1, A2, A7},
     Error as VMError, Memory, Register, SupportMachine, Syscalls,
+    registers::{A0, A1, A2, A7},
 };
 use std::sync::{Arc, Mutex};
 
diff --git a/script/src/type_id.rs b/script/src/type_id.rs
index 30d8d537dc..f3172b24a9 100644
--- a/script/src/type_id.rs
+++ b/script/src/type_id.rs
@@ -1,7 +1,7 @@
 use crate::{ScriptError, ScriptGroup};
 use ckb_hash::new_blake2b;
 use ckb_types::{
-    core::{cell::ResolvedTransaction, Cycle},
+    core::{Cycle, cell::ResolvedTransaction},
     prelude::*,
 };
 
diff --git a/script/src/types.rs b/script/src/types.rs
index bf1bbf288b..c9d5cd1baa 100644
--- a/script/src/types.rs
+++ b/script/src/types.rs
@@ -2,22 +2,22 @@ use crate::{error::ScriptError, verify_env::TxVerifyEnv};
 use ckb_chain_spec::consensus::Consensus;
 use ckb_types::{
     core::{
-        cell::{CellMeta, ResolvedTransaction},
         Cycle, ScriptHashType,
+        cell::{CellMeta, ResolvedTransaction},
     },
     packed::{Byte32, CellOutput, OutPoint, Script},
     prelude::*,
 };
 use ckb_vm::{
-    machine::{VERSION0, VERSION1, VERSION2},
     ISA_B, ISA_IMC, ISA_MOP,
+    machine::{VERSION0, VERSION1, VERSION2},
 };
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap};
 use std::fmt;
 use std::sync::{
-    atomic::{AtomicU64, Ordering},
     Arc, Mutex, RwLock,
+    atomic::{AtomicU64, Ordering},
 };
 
 #[cfg(has_asm)]
@@ -30,10 +30,10 @@ use ckb_traits::CellDataProvider;
 use ckb_vm::snapshot2::Snapshot2Context;
 
 use ckb_vm::{
+    RISCV_GENERAL_REGISTER_NUMBER,
     bytes::Bytes,
     machine::Pause,
     snapshot2::{DataSource, Snapshot2},
-    RISCV_GENERAL_REGISTER_NUMBER,
 };
 use std::mem::size_of;
 
diff --git a/script/src/verify.rs b/script/src/verify.rs
index aaa5fd41d0..f38a3a9886 100644
--- a/script/src/verify.rs
+++ b/script/src/verify.rs
@@ -1,6 +1,6 @@
-use crate::scheduler::Scheduler;
 #[cfg(not(target_family = "wasm"))]
 use crate::ChunkCommand;
+use crate::scheduler::Scheduler;
 use crate::{
     error::{ScriptError, TransactionScriptError},
     type_id::TypeIdSystemScript,
@@ -17,13 +17,13 @@ use ckb_logger::{debug, info};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_types::{
     bytes::Bytes,
-    core::{cell::ResolvedTransaction, Cycle, ScriptHashType},
+    core::{Cycle, ScriptHashType, cell::ResolvedTransaction},
     packed::{Byte32, Script},
     prelude::*,
 };
+use ckb_vm::Error as VMInternalError;
 #[cfg(not(target_family = "wasm"))]
 use ckb_vm::machine::Pause as VMPause;
-use ckb_vm::Error as VMInternalError;
 use std::sync::Arc;
 #[cfg(not(target_family = "wasm"))]
 use tokio::sync::{
@@ -710,7 +710,7 @@ fn wrapping_cycles_add(
 
 #[cfg(feature = "logging")]
 mod logging {
-    use super::{info, Byte32, ScriptError};
+    use super::{Byte32, ScriptError, info};
 
     pub fn on_script_error(group: &Byte32, tx: &Byte32, error: &ScriptError) {
         info!(
diff --git a/script/src/verify/tests/ckb_latest/features_since_v2019.rs b/script/src/verify/tests/ckb_latest/features_since_v2019.rs
index 74eccdef75..d329ca1a46 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2019.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2019.rs
@@ -5,7 +5,7 @@ use ckb_error::assert_error_eq;
 use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_test_chain_utils::always_success_cell;
 use ckb_types::{
-    core::{capacity_bytes, cell::CellMetaBuilder, Capacity, ScriptHashType, TransactionBuilder},
+    core::{Capacity, ScriptHashType, TransactionBuilder, capacity_bytes, cell::CellMetaBuilder},
     h256,
     packed::{self, CellDep, CellInput, CellOutputBuilder, OutPoint, Script},
 };
diff --git a/script/src/verify/tests/ckb_latest/features_since_v2021.rs b/script/src/verify/tests/ckb_latest/features_since_v2021.rs
index 32a3196dc2..0fa3feb107 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2021.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2021.rs
@@ -2,22 +2,22 @@ use ckb_chain_spec::consensus::{TWO_IN_TWO_OUT_CYCLES, TYPE_ID_CODE_HASH};
 use ckb_error::assert_error_eq;
 use ckb_test_chain_utils::always_success_cell;
 use ckb_types::{
-    core::{capacity_bytes, cell::CellMetaBuilder, Capacity, ScriptHashType, TransactionBuilder},
+    core::{Capacity, ScriptHashType, TransactionBuilder, capacity_bytes, cell::CellMetaBuilder},
     h256,
     packed::{self, CellDep, CellInput, CellOutputBuilder, OutPoint, Script},
 };
 use ckb_vm::Error as VmError;
 use proptest::{prelude::*, prop_assert_eq, proptest};
 use rand::distributions::Uniform;
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 use std::{collections::VecDeque, io::Read};
 
 use super::SCRIPT_VERSION;
 use crate::syscalls::SOURCE_GROUP_FLAG;
 use crate::{
+    ScriptError,
     type_id::TYPE_ID_CYCLES,
     verify::{tests::utils::*, *},
-    ScriptError,
 };
 
 #[test]
@@ -496,10 +496,12 @@ fn check_exec_big_offset_length() {
             assert!(result.unwrap_err().to_string().contains("error code 3"));
         }
         _ => {
-            assert!(result
-                .unwrap_err()
-                .to_string()
-                .contains("VM Internal Error: ElfParseError"));
+            assert!(
+                result
+                    .unwrap_err()
+                    .to_string()
+                    .contains("VM Internal Error: ElfParseError")
+            );
         }
     }
 }
diff --git a/script/src/verify/tests/ckb_latest/features_since_v2023.rs b/script/src/verify/tests/ckb_latest/features_since_v2023.rs
index 389fcd1600..20658c8bf8 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2023.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2023.rs
@@ -3,7 +3,7 @@ use crate::scheduler::{MAX_FDS, MAX_VMS_COUNT};
 use crate::syscalls::SOURCE_GROUP_FLAG;
 use crate::verify::{tests::utils::*, *};
 use ckb_types::{
-    core::{capacity_bytes, cell::CellMetaBuilder, Capacity, TransactionBuilder},
+    core::{Capacity, TransactionBuilder, capacity_bytes, cell::CellMetaBuilder},
     packed::{CellInput, CellOutputBuilder, OutPoint, Script},
 };
 use proptest::prelude::*;
@@ -205,10 +205,12 @@ fn check_spawn_out_of_cycles() {
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify(script_version, &rtx, 0xffffff);
     if script_version >= ScriptVersion::V2 {
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("ExceededMaximumCycles"))
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("ExceededMaximumCycles")
+        )
     } else {
         assert!(result.is_err())
     }
@@ -323,10 +325,12 @@ fn check_spawn_out_of_cycles_wrap() {
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify(script_version, &rtx, 0xffffff);
     if script_version >= ScriptVersion::V2 {
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("ExceededMaximumCycles"))
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("ExceededMaximumCycles")
+        )
     } else {
         assert!(result.is_err());
     }
@@ -857,7 +861,7 @@ mod spawn_dag;
 use ckb_types::bytes::Bytes;
 use daggy::{Dag, Walker};
 use molecule::prelude::Byte;
-use rand::{rngs::StdRng, Rng, SeedableRng};
+use rand::{Rng, SeedableRng, rngs::StdRng};
 use spawn_dag as dag;
 use std::collections::{HashSet, VecDeque};
 
@@ -1364,10 +1368,12 @@ fn check_infinite_exec() {
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify(script_version, &rtx, 70000000);
     if script_version >= ScriptVersion::V1 {
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("ExceededMaximumCycles"))
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("ExceededMaximumCycles")
+        )
     } else {
         assert!(result.is_err())
     }
@@ -1401,14 +1407,18 @@ fn check_fuzz_crash_1() {
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify(script_version, &rtx, 70000000);
     match script_version {
-        ScriptVersion::V0 => assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("MemWriteOnExecutablePage")),
-        ScriptVersion::V1 | ScriptVersion::V2 => assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("SourceEntry parse_from_u64 0")),
+        ScriptVersion::V0 => assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("MemWriteOnExecutablePage")
+        ),
+        ScriptVersion::V1 | ScriptVersion::V2 => assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("SourceEntry parse_from_u64 0")
+        ),
     }
 }
 
@@ -1436,10 +1446,12 @@ fn check_fuzz_crash_2() {
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify(script_version, &rtx, 70000000);
     match script_version {
-        ScriptVersion::V0 => assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("MemWriteOnExecutablePage")),
+        ScriptVersion::V0 => assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("MemWriteOnExecutablePage")
+        ),
         ScriptVersion::V1 => assert_eq!(result.unwrap(), 58741),
         ScriptVersion::V2 => assert_eq!(result.unwrap(), 58686),
     }
@@ -1468,8 +1480,10 @@ fn check_fuzz_crash_3() {
     };
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify(script_version, &rtx, 70000000);
-    assert!(result
-        .unwrap_err()
-        .to_string()
-        .contains("MemWriteOnExecutablePage"));
+    assert!(
+        result
+            .unwrap_err()
+            .to_string()
+            .contains("MemWriteOnExecutablePage")
+    );
 }
diff --git a/script/src/verify/tests/utils.rs b/script/src/verify/tests/utils.rs
index 1ebd0d0b8a..7cfe6736fa 100644
--- a/script/src/verify/tests/utils.rs
+++ b/script/src/verify/tests/utils.rs
@@ -5,27 +5,26 @@ use ckb_db::RocksDB;
 use ckb_db_schema::COLUMNS;
 use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_store::{
-    data_loader_wrapper::{AsDataLoader, DataLoaderWrapper},
     ChainDB,
+    data_loader_wrapper::{AsDataLoader, DataLoaderWrapper},
 };
 use ckb_test_chain_utils::{
     ckb_testnet_consensus, secp256k1_blake160_sighash_cell, secp256k1_data_cell,
     type_lock_script_code_hash,
 };
 use ckb_types::{
+    H256,
     core::{
-        capacity_bytes,
-        cell::{CellMeta, CellMetaBuilder},
-        hardfork::{HardForks, CKB2021, CKB2023},
         Capacity, Cycle, DepType, EpochNumber, EpochNumberWithFraction, HeaderView, ScriptHashType,
-        TransactionBuilder, TransactionInfo,
+        TransactionBuilder, TransactionInfo, capacity_bytes,
+        cell::{CellMeta, CellMetaBuilder},
+        hardfork::{CKB2021, CKB2023, HardForks},
     },
     h256,
     packed::{
         Byte32, CellDep, CellInput, CellOutput, OutPoint, Script, TransactionInfoBuilder,
         TransactionKeyBuilder, WitnessArgs,
     },
-    H256,
 };
 use faster_hex::hex_encode;
 use std::sync::Arc;
diff --git a/shared/src/shared.rs b/shared/src/shared.rs
index 51ef537a00..425f80283c 100644
--- a/shared/src/shared.rs
+++ b/shared/src/shared.rs
@@ -18,18 +18,18 @@ use ckb_store::{ChainDB, ChainStore};
 use ckb_systemtime::unix_time_as_millis;
 use ckb_tx_pool::{BlockTemplate, TokioRwLock, TxPoolController};
 use ckb_types::{
+    H256, U256,
     core::{BlockNumber, EpochExt, EpochNumber, HeaderView, Version},
     packed::{self, Byte32},
     prelude::*,
-    H256, U256,
 };
-use ckb_util::{shrink_to_fit, Mutex, MutexGuard};
+use ckb_util::{Mutex, MutexGuard, shrink_to_fit};
 use ckb_verification::cache::TxVerificationCache;
 use dashmap::DashMap;
 use std::cmp;
 use std::collections::BTreeMap;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread;
 use std::time::Duration;
 
@@ -120,18 +120,20 @@ impl Shared {
             let signal_receiver = new_crossbeam_exit_rx();
             let shared = self.clone();
             let freeze_jh = thread::Builder::new()
-                .spawn(move || loop {
-                    match signal_receiver.recv_timeout(FREEZER_INTERVAL) {
-                        Err(_) => {
-                            if let Err(e) = shared.freeze() {
-                                ckb_logger::error!("Freezer error {}", e);
+                .spawn(move || {
+                    loop {
+                        match signal_receiver.recv_timeout(FREEZER_INTERVAL) {
+                            Err(_) => {
+                                if let Err(e) = shared.freeze() {
+                                    ckb_logger::error!("Freezer error {}", e);
+                                    break;
+                                }
+                            }
+                            Ok(_) => {
+                                ckb_logger::info!("Freezer closing");
                                 break;
                             }
                         }
-                        Ok(_) => {
-                            ckb_logger::info!("Freezer closing");
-                            break;
-                        }
                     }
                 })
                 .expect("Start FreezerService failed");
diff --git a/shared/src/shared_builder.rs b/shared/src/shared_builder.rs
index 8f97def62e..b6970e948d 100644
--- a/shared/src/shared_builder.rs
+++ b/shared/src/shared_builder.rs
@@ -5,9 +5,9 @@ use ckb_app_config::{
     BlockAssemblerConfig, DBConfig, ExitCode, FeeEstimatorAlgo, FeeEstimatorConfig, NotifyConfig,
     StoreConfig, SyncConfig, TxPoolConfig,
 };
-use ckb_async_runtime::{new_background_runtime, Handle};
-use ckb_chain_spec::consensus::Consensus;
+use ckb_async_runtime::{Handle, new_background_runtime};
 use ckb_chain_spec::SpecError;
+use ckb_chain_spec::consensus::Consensus;
 use ckb_channel::Receiver;
 use ckb_db::RocksDB;
 use ckb_db_schema::COLUMNS;
@@ -21,13 +21,13 @@ use ckb_proposal_table::ProposalView;
 use ckb_snapshot::{Snapshot, SnapshotMgr};
 use ckb_store::{ChainDB, ChainStore, Freezer};
 use ckb_tx_pool::{
-    service::TxVerificationResult, TokioRwLock, TxEntry, TxPool, TxPoolServiceBuilder,
+    TokioRwLock, TxEntry, TxPool, TxPoolServiceBuilder, service::TxVerificationResult,
 };
+use ckb_types::H256;
 use ckb_types::core::hardfork::HardForks;
 use ckb_types::prelude::Pack;
-use ckb_types::H256;
 use ckb_types::{
-    core::service::PoolTransactionEntry, core::tx_pool::Reject, core::EpochExt, core::HeaderView,
+    core::EpochExt, core::HeaderView, core::service::PoolTransactionEntry, core::tx_pool::Reject,
 };
 use ckb_util::Mutex;
 use ckb_verification::cache::init_cache;
@@ -35,8 +35,8 @@ use dashmap::DashMap;
 use std::cmp::Ordering;
 use std::collections::HashSet;
 use std::path::{Path, PathBuf};
-use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 use tempfile::TempDir;
 
 /// Shared builder for construct new shared.
diff --git a/shared/src/types/header_map/kernel_lru.rs b/shared/src/types/header_map/kernel_lru.rs
index c82404658e..41607b6d87 100644
--- a/shared/src/types/header_map/kernel_lru.rs
+++ b/shared/src/types/header_map/kernel_lru.rs
@@ -1,6 +1,6 @@
 use std::path;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 #[cfg(feature = "stats")]
 use ckb_logger::info;
diff --git a/shared/src/types/header_map/memory.rs b/shared/src/types/header_map/memory.rs
index 7a01b83891..24338217a5 100644
--- a/shared/src/types/header_map/memory.rs
+++ b/shared/src/types/header_map/memory.rs
@@ -1,10 +1,10 @@
 use crate::types::HeaderIndexView;
 use ckb_types::{
+    U256,
     core::{BlockNumber, EpochNumberWithFraction},
     packed::Byte32,
-    U256,
 };
-use ckb_util::{shrink_to_fit, LinkedHashMap, RwLock};
+use ckb_util::{LinkedHashMap, RwLock, shrink_to_fit};
 use std::default;
 
 const SHRINK_THRESHOLD: usize = 300;
diff --git a/shared/src/types/header_map/mod.rs b/shared/src/types/header_map/mod.rs
index e7536e5cf2..f820fd967b 100644
--- a/shared/src/types/header_map/mod.rs
+++ b/shared/src/types/header_map/mod.rs
@@ -1,9 +1,9 @@
 use ckb_async_runtime::Handle;
 use ckb_logger::info;
-use ckb_stop_handler::{new_tokio_exit_rx, CancellationToken};
+use ckb_stop_handler::{CancellationToken, new_tokio_exit_rx};
 use ckb_types::packed::Byte32;
-use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 use std::time::Duration;
 use std::{mem::size_of, path};
 
diff --git a/shared/src/types/mod.rs b/shared/src/types/mod.rs
index 81a0495350..ae3b951b46 100644
--- a/shared/src/types/mod.rs
+++ b/shared/src/types/mod.rs
@@ -2,7 +2,7 @@
 use ckb_types::core::{BlockNumber, EpochNumberWithFraction};
 use ckb_types::packed::Byte32;
 use ckb_types::prelude::{Entity, FromSliceShouldBeOk, Reader};
-use ckb_types::{packed, BlockNumberAndHash, U256};
+use ckb_types::{BlockNumberAndHash, U256, packed};
 
 pub mod header_map;
 
diff --git a/spec/src/consensus.rs b/spec/src/consensus.rs
index 4f0dc6a7ac..f2c0fa9964 100644
--- a/spec/src/consensus.rs
+++ b/spec/src/consensus.rs
@@ -4,13 +4,12 @@
 #![allow(clippy::inconsistent_digit_grouping)]
 
 use crate::{
-    calculate_block_reward,
+    OUTPUT_INDEX_DAO, OUTPUT_INDEX_SECP256K1_BLAKE160_MULTISIG_ALL,
+    OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL, calculate_block_reward,
     versionbits::{
         self, Deployment, DeploymentPos, ThresholdState, Versionbits, VersionbitsCache,
         VersionbitsConditionChecker, VersionbitsIndexer,
     },
-    OUTPUT_INDEX_DAO, OUTPUT_INDEX_SECP256K1_BLAKE160_MULTISIG_ALL,
-    OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL,
 };
 use ckb_constant::{
     consensus::TAU,
@@ -23,18 +22,18 @@ use ckb_rational::RationalU256;
 use ckb_resource::Resource;
 use ckb_traits::{BlockEpoch, EpochProvider};
 use ckb_types::{
+    H160, H256, U256,
     bytes::Bytes,
     constants::{BLOCK_VERSION, TX_VERSION},
     core::{
-        hardfork::HardForks, BlockBuilder, BlockNumber, BlockView, Capacity, Cycle, EpochExt,
-        EpochNumber, EpochNumberWithFraction, HeaderView, Ratio, TransactionBuilder,
-        TransactionView, Version,
+        BlockBuilder, BlockNumber, BlockView, Capacity, Cycle, EpochExt, EpochNumber,
+        EpochNumberWithFraction, HeaderView, Ratio, TransactionBuilder, TransactionView, Version,
+        hardfork::HardForks,
     },
     h160, h256,
     packed::{Byte32, CellInput, CellOutput, Script},
     prelude::*,
-    utilities::{compact_to_difficulty, difficulty_to_compact, DIFF_TWO},
-    H160, H256, U256,
+    utilities::{DIFF_TWO, compact_to_difficulty, difficulty_to_compact},
 };
 use std::cmp;
 use std::collections::HashMap;
diff --git a/spec/src/error.rs b/spec/src/error.rs
index 04dee7de4c..36344f5c07 100644
--- a/spec/src/error.rs
+++ b/spec/src/error.rs
@@ -1,4 +1,4 @@
-use ckb_error::{prelude::*, Error, ErrorKind};
+use ckb_error::{Error, ErrorKind, prelude::*};
 use ckb_types::packed::Byte32;
 
 /// The error type for Spec operations
diff --git a/spec/src/hardfork.rs b/spec/src/hardfork.rs
index 6d304025b1..40d484d5be 100644
--- a/spec/src/hardfork.rs
+++ b/spec/src/hardfork.rs
@@ -2,8 +2,8 @@
 
 use ckb_constant::hardfork::{mainnet, testnet};
 use ckb_types::core::{
-    hardfork::{CKB2021Builder, CKB2023Builder, HardForks, CKB2021, CKB2023},
     EpochNumber,
+    hardfork::{CKB2021, CKB2021Builder, CKB2023, CKB2023Builder, HardForks},
 };
 use serde::{Deserialize, Serialize};
 
diff --git a/spec/src/lib.rs b/spec/src/lib.rs
index 4e029bc6cb..ed03109250 100644
--- a/spec/src/lib.rs
+++ b/spec/src/lib.rs
@@ -11,9 +11,9 @@
 // details https://docs.rs/toml/0.5.0/toml/ser/index.html
 
 use crate::consensus::{
-    build_genesis_dao_data, build_genesis_epoch_ext, Consensus, ConsensusBuilder,
-    SATOSHI_CELL_OCCUPIED_RATIO, SATOSHI_PUBKEY_HASH, TESTNET_ACTIVATION_THRESHOLD,
-    TYPE_ID_CODE_HASH,
+    Consensus, ConsensusBuilder, SATOSHI_CELL_OCCUPIED_RATIO, SATOSHI_PUBKEY_HASH,
+    TESTNET_ACTIVATION_THRESHOLD, TYPE_ID_CODE_HASH, build_genesis_dao_data,
+    build_genesis_epoch_ext,
 };
 use crate::versionbits::{ActiveMode, Deployment, DeploymentPos};
 use ckb_constant::hardfork::{mainnet, testnet};
@@ -22,19 +22,19 @@ use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_jsonrpc_types::Script;
 use ckb_pow::{Pow, PowEngine};
 use ckb_resource::{
-    Resource, CODE_HASH_DAO, CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL,
-    CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL, CODE_HASH_SECP256K1_DATA,
+    CODE_HASH_DAO, CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL,
+    CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL, CODE_HASH_SECP256K1_DATA, Resource,
 };
 use ckb_types::{
+    H160, H256, U128,
     bytes::Bytes,
     core::{
-        capacity_bytes, hardfork::HardForks, BlockBuilder, BlockNumber, BlockView, Capacity, Cycle,
-        EpochNumber, EpochNumberWithFraction, Ratio, ScriptHashType, TransactionBuilder,
-        TransactionView,
+        BlockBuilder, BlockNumber, BlockView, Capacity, Cycle, EpochNumber,
+        EpochNumberWithFraction, Ratio, ScriptHashType, TransactionBuilder, TransactionView,
+        capacity_bytes, hardfork::HardForks,
     },
     h256, packed,
     prelude::*,
-    H160, H256, U128,
 };
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
diff --git a/spec/src/tests/consensus.rs b/spec/src/tests/consensus.rs
index eaa250ad76..a0d35a2c75 100644
--- a/spec/src/tests/consensus.rs
+++ b/spec/src/tests/consensus.rs
@@ -1,8 +1,8 @@
 use ckb_traits::{BlockEpoch, EpochProvider};
 use ckb_types::{
     core::{
-        capacity_bytes, BlockBuilder, BlockExt, BlockNumber, Capacity, EpochExt, HeaderBuilder,
-        HeaderView, TransactionBuilder,
+        BlockBuilder, BlockExt, BlockNumber, Capacity, EpochExt, HeaderBuilder, HeaderView,
+        TransactionBuilder, capacity_bytes,
     },
     packed::{Byte32, Bytes},
     prelude::*,
@@ -10,8 +10,8 @@ use ckb_types::{
 };
 
 use crate::consensus::{
-    build_genesis_epoch_ext, ConsensusBuilder, DEFAULT_EPOCH_DURATION_TARGET,
-    DEFAULT_ORPHAN_RATE_TARGET, GENESIS_EPOCH_LENGTH,
+    ConsensusBuilder, DEFAULT_EPOCH_DURATION_TARGET, DEFAULT_ORPHAN_RATE_TARGET,
+    GENESIS_EPOCH_LENGTH, build_genesis_epoch_ext,
 };
 
 #[test]
diff --git a/spec/src/tests/mod.rs b/spec/src/tests/mod.rs
index ad621c1597..f5e2df9284 100644
--- a/spec/src/tests/mod.rs
+++ b/spec/src/tests/mod.rs
@@ -1,9 +1,9 @@
 use ckb_resource::Resource;
-use ckb_types::{core::Capacity, packed, prelude::*, H256};
+use ckb_types::{H256, core::Capacity, packed, prelude::*};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-use crate::{build_genesis_epoch_ext, ChainSpec, Params};
+use crate::{ChainSpec, Params, build_genesis_epoch_ext};
 
 mod consensus;
 mod versionbits;
@@ -240,7 +240,7 @@ fn test_params_skip_serializing_if_option_is_none() {
 #[test]
 fn test_default_genesis_epoch_ext() {
     use ckb_types::core::EpochExt;
-    use ckb_types::{packed, U256};
+    use ckb_types::{U256, packed};
 
     let params = Params::default();
     let compact_target = 0x1a08a97e;
diff --git a/spec/src/tests/versionbits.rs b/spec/src/tests/versionbits.rs
index bcbb3aea57..060fdcf7d7 100644
--- a/spec/src/tests/versionbits.rs
+++ b/spec/src/tests/versionbits.rs
@@ -1,16 +1,16 @@
+use crate::TESTNET_ACTIVATION_THRESHOLD;
 use crate::consensus::Consensus;
 use crate::consensus::{
-    build_genesis_epoch_ext, ConsensusBuilder, DEFAULT_EPOCH_DURATION_TARGET,
-    DEFAULT_ORPHAN_RATE_TARGET,
+    ConsensusBuilder, DEFAULT_EPOCH_DURATION_TARGET, DEFAULT_ORPHAN_RATE_TARGET,
+    build_genesis_epoch_ext,
 };
 use crate::versionbits::{
     ActiveMode, Deployment, DeploymentPos, ThresholdState, VersionbitsIndexer,
 };
-use crate::TESTNET_ACTIVATION_THRESHOLD;
 use ckb_types::{
     core::{
-        capacity_bytes, BlockBuilder, BlockView, Capacity, EpochExt, EpochNumber, HeaderView,
-        TransactionBuilder, TransactionView, Version,
+        BlockBuilder, BlockView, Capacity, EpochExt, EpochNumber, HeaderView, TransactionBuilder,
+        TransactionView, Version, capacity_bytes,
     },
     global::DATA_DIR,
     packed::{Byte32, Bytes, CellbaseWitness},
diff --git a/store/src/db.rs b/store/src/db.rs
index 88b1da32fc..5576a1d929 100644
--- a/store/src/db.rs
+++ b/store/src/db.rs
@@ -1,16 +1,16 @@
+use crate::StoreSnapshot;
 use crate::cache::StoreCache;
 use crate::cell::attach_block_cell;
 use crate::store::ChainStore;
 use crate::transaction::StoreTransaction;
 use crate::write_batch::StoreWriteBatch;
-use crate::StoreSnapshot;
 use ckb_app_config::StoreConfig;
 use ckb_chain_spec::{consensus::Consensus, versionbits::VersionbitsIndexer};
 use ckb_db::{
-    iter::{DBIter, DBIterator, IteratorMode},
     DBPinnableSlice, RocksDB,
+    iter::{DBIter, DBIterator, IteratorMode},
 };
-use ckb_db_schema::{Col, CHAIN_SPEC_HASH_KEY, MIGRATION_VERSION_KEY};
+use ckb_db_schema::{CHAIN_SPEC_HASH_KEY, Col, MIGRATION_VERSION_KEY};
 use ckb_error::{Error, InternalErrorKind};
 use ckb_freezer::Freezer;
 use ckb_types::{
diff --git a/store/src/snapshot.rs b/store/src/snapshot.rs
index 57579abc41..a660e0caff 100644
--- a/store/src/snapshot.rs
+++ b/store/src/snapshot.rs
@@ -1,8 +1,8 @@
 use crate::cache::StoreCache;
 use crate::store::ChainStore;
 use ckb_db::{
-    iter::{DBIter, DBIterator, IteratorMode},
     DBPinnableSlice, RocksDBSnapshot,
+    iter::{DBIter, DBIterator, IteratorMode},
 };
 use ckb_db_schema::Col;
 use ckb_freezer::Freezer;
diff --git a/store/src/store.rs b/store/src/store.rs
index 4e3ce0c1d4..2ddecd49d5 100644
--- a/store/src/store.rs
+++ b/store/src/store.rs
@@ -1,22 +1,23 @@
 use crate::cache::StoreCache;
 use crate::data_loader_wrapper::BorrowedDataLoaderWrapper;
 use ckb_db::{
-    iter::{DBIter, Direction, IteratorMode},
     DBPinnableSlice,
+    iter::{DBIter, Direction, IteratorMode},
 };
 use ckb_db_schema::{
-    Col, COLUMN_BLOCK_BODY, COLUMN_BLOCK_EPOCH, COLUMN_BLOCK_EXT, COLUMN_BLOCK_EXTENSION,
+    COLUMN_BLOCK_BODY, COLUMN_BLOCK_EPOCH, COLUMN_BLOCK_EXT, COLUMN_BLOCK_EXTENSION,
     COLUMN_BLOCK_FILTER, COLUMN_BLOCK_FILTER_HASH, COLUMN_BLOCK_HEADER, COLUMN_BLOCK_PROPOSAL_IDS,
     COLUMN_BLOCK_UNCLE, COLUMN_CELL, COLUMN_CELL_DATA, COLUMN_CELL_DATA_HASH,
     COLUMN_CHAIN_ROOT_MMR, COLUMN_EPOCH, COLUMN_INDEX, COLUMN_META, COLUMN_TRANSACTION_INFO,
-    COLUMN_UNCLES, META_CURRENT_EPOCH_KEY, META_LATEST_BUILT_FILTER_DATA_KEY, META_TIP_HEADER_KEY,
+    COLUMN_UNCLES, Col, META_CURRENT_EPOCH_KEY, META_LATEST_BUILT_FILTER_DATA_KEY,
+    META_TIP_HEADER_KEY,
 };
 use ckb_freezer::Freezer;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        cell::CellMeta, BlockExt, BlockNumber, BlockView, EpochExt, EpochNumber, HeaderView,
-        TransactionInfo, TransactionView, UncleBlockVecView,
+        BlockExt, BlockNumber, BlockView, EpochExt, EpochNumber, HeaderView, TransactionInfo,
+        TransactionView, UncleBlockVecView, cell::CellMeta,
     },
     packed::{self, OutPoint},
     prelude::*,
diff --git a/store/src/tests/db.rs b/store/src/tests/db.rs
index 39e1d24d61..5cf51a3100 100644
--- a/store/src/tests/db.rs
+++ b/store/src/tests/db.rs
@@ -1,6 +1,6 @@
 use ckb_chain_spec::consensus::ConsensusBuilder;
 use ckb_db::RocksDB;
-use ckb_db_schema::{COLUMNS, COLUMN_BLOCK_HEADER};
+use ckb_db_schema::{COLUMN_BLOCK_HEADER, COLUMNS};
 use ckb_freezer::Freezer;
 use ckb_types::{core::BlockExt, packed, prelude::*};
 use tempfile::TempDir;
diff --git a/store/src/transaction.rs b/store/src/transaction.rs
index 62ba110b0f..a19e0db68a 100644
--- a/store/src/transaction.rs
+++ b/store/src/transaction.rs
@@ -2,15 +2,15 @@ use crate::cache::StoreCache;
 use crate::store::ChainStore;
 use ckb_chain_spec::versionbits::VersionbitsIndexer;
 use ckb_db::{
-    iter::{DBIter, DBIterator, IteratorMode},
     DBPinnableSlice, RocksDBTransaction, RocksDBTransactionSnapshot,
+    iter::{DBIter, DBIterator, IteratorMode},
 };
 use ckb_db_schema::{
-    Col, COLUMN_BLOCK_BODY, COLUMN_BLOCK_EPOCH, COLUMN_BLOCK_EXT, COLUMN_BLOCK_EXTENSION,
+    COLUMN_BLOCK_BODY, COLUMN_BLOCK_EPOCH, COLUMN_BLOCK_EXT, COLUMN_BLOCK_EXTENSION,
     COLUMN_BLOCK_FILTER, COLUMN_BLOCK_FILTER_HASH, COLUMN_BLOCK_HEADER, COLUMN_BLOCK_PROPOSAL_IDS,
     COLUMN_BLOCK_UNCLE, COLUMN_CELL, COLUMN_CELL_DATA, COLUMN_CELL_DATA_HASH,
     COLUMN_CHAIN_ROOT_MMR, COLUMN_EPOCH, COLUMN_INDEX, COLUMN_META, COLUMN_NUMBER_HASH,
-    COLUMN_TRANSACTION_INFO, COLUMN_UNCLES, META_CURRENT_EPOCH_KEY,
+    COLUMN_TRANSACTION_INFO, COLUMN_UNCLES, Col, META_CURRENT_EPOCH_KEY,
     META_LATEST_BUILT_FILTER_DATA_KEY, META_TIP_HEADER_KEY,
 };
 use ckb_error::Error;
@@ -18,8 +18,8 @@ use ckb_freezer::Freezer;
 use ckb_merkle_mountain_range::{Error as MMRError, MMRStore, Result as MMRResult};
 use ckb_types::{
     core::{
-        cell::{CellChecker, CellProvider, CellStatus},
         BlockExt, BlockView, EpochExt, HeaderView, TransactionView,
+        cell::{CellChecker, CellProvider, CellStatus},
     },
     packed::{self, Byte32, OutPoint},
     prelude::*,
diff --git a/store/src/write_batch.rs b/store/src/write_batch.rs
index 65d74e2dc1..ec92a0135e 100644
--- a/store/src/write_batch.rs
+++ b/store/src/write_batch.rs
@@ -1,7 +1,8 @@
 use ckb_db::RocksDBWriteBatch;
 use ckb_db_schema::{
-    Col, COLUMN_BLOCK_BODY, COLUMN_BLOCK_EXTENSION, COLUMN_BLOCK_HEADER, COLUMN_BLOCK_PROPOSAL_IDS,
+    COLUMN_BLOCK_BODY, COLUMN_BLOCK_EXTENSION, COLUMN_BLOCK_HEADER, COLUMN_BLOCK_PROPOSAL_IDS,
     COLUMN_BLOCK_UNCLE, COLUMN_CELL, COLUMN_CELL_DATA, COLUMN_CELL_DATA_HASH, COLUMN_NUMBER_HASH,
+    Col,
 };
 use ckb_error::Error;
 use ckb_types::{core::BlockNumber, packed, prelude::*};
diff --git a/sync/src/filter/get_block_filter_check_points_process.rs b/sync/src/filter/get_block_filter_check_points_process.rs
index a194525052..f8e0bf7a9c 100644
--- a/sync/src/filter/get_block_filter_check_points_process.rs
+++ b/sync/src/filter/get_block_filter_check_points_process.rs
@@ -1,6 +1,6 @@
 use crate::filter::BlockFilter;
 use crate::utils::send_message_to;
-use crate::{attempt, Status};
+use crate::{Status, attempt};
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_types::core::BlockNumber;
 use ckb_types::{packed, prelude::*};
diff --git a/sync/src/filter/get_block_filter_hashes_process.rs b/sync/src/filter/get_block_filter_hashes_process.rs
index c1a3f5a6e0..6f8338f0c6 100644
--- a/sync/src/filter/get_block_filter_hashes_process.rs
+++ b/sync/src/filter/get_block_filter_hashes_process.rs
@@ -1,6 +1,6 @@
 use crate::filter::BlockFilter;
 use crate::utils::send_message_to;
-use crate::{attempt, Status};
+use crate::{Status, attempt};
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_types::{core::BlockNumber, packed, prelude::*};
 use std::sync::Arc;
diff --git a/sync/src/filter/get_block_filters_process.rs b/sync/src/filter/get_block_filters_process.rs
index 22e527f0e5..745e0c4442 100644
--- a/sync/src/filter/get_block_filters_process.rs
+++ b/sync/src/filter/get_block_filters_process.rs
@@ -1,6 +1,6 @@
 use crate::filter::BlockFilter;
 use crate::utils::send_message_to;
-use crate::{attempt, Status};
+use crate::{Status, attempt};
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_types::core::BlockNumber;
 use ckb_types::{packed, prelude::*};
diff --git a/sync/src/filter/mod.rs b/sync/src/filter/mod.rs
index f471386a78..7e4b1a76b6 100644
--- a/sync/src/filter/mod.rs
+++ b/sync/src/filter/mod.rs
@@ -2,16 +2,16 @@ mod get_block_filter_check_points_process;
 mod get_block_filter_hashes_process;
 mod get_block_filters_process;
 
-use crate::{types::SyncShared, Status};
+use crate::{Status, types::SyncShared};
 use get_block_filter_check_points_process::GetBlockFilterCheckPointsProcess;
 use get_block_filter_hashes_process::GetBlockFilterHashesProcess;
 use get_block_filters_process::GetBlockFiltersProcess;
 
-use crate::utils::{metric_ckb_message_bytes, MetricDirection};
+use crate::utils::{MetricDirection, metric_ckb_message_bytes};
 use ckb_constant::sync::BAD_MESSAGE_BAN_TIME;
 use ckb_logger::{debug_target, error_target, info_target, warn_target};
 use ckb_network::{
-    async_trait, bytes::Bytes, CKBProtocolContext, CKBProtocolHandler, PeerIndex, SupportProtocols,
+    CKBProtocolContext, CKBProtocolHandler, PeerIndex, SupportProtocols, async_trait, bytes::Bytes,
 };
 use ckb_types::{packed, prelude::*};
 use std::sync::Arc;
diff --git a/sync/src/net_time_checker.rs b/sync/src/net_time_checker.rs
index 259a2eae57..3ea989cf2a 100644
--- a/sync/src/net_time_checker.rs
+++ b/sync/src/net_time_checker.rs
@@ -2,7 +2,7 @@ use crate::utils::send_message_to;
 use ckb_constant::sync::BAD_MESSAGE_BAN_TIME;
 use ckb_logger::{debug, info, warn};
 use ckb_network::async_trait;
-use ckb_network::{bytes::Bytes, CKBProtocolContext, CKBProtocolHandler, PeerIndex};
+use ckb_network::{CKBProtocolContext, CKBProtocolHandler, PeerIndex, bytes::Bytes};
 use ckb_types::{packed, prelude::*};
 use ckb_util::RwLock;
 use std::collections::VecDeque;
@@ -158,7 +158,10 @@ impl CKBProtocolHandler for NetTimeProtocol {
         debug!("New net time offset sample {}ms", offset);
         net_time_checker.add_sample(offset);
         if let Err(offset) = net_time_checker.check() {
-            warn!("Please check your computer's local clock ({}ms offset from network peers). Incorrect time setting may cause unexpected errors.", offset);
+            warn!(
+                "Please check your computer's local clock ({}ms offset from network peers). Incorrect time setting may cause unexpected errors.",
+                offset
+            );
         }
     }
 }
diff --git a/sync/src/relayer/block_transactions_process.rs b/sync/src/relayer/block_transactions_process.rs
index fa5522e349..e60eeff763 100644
--- a/sync/src/relayer/block_transactions_process.rs
+++ b/sync/src/relayer/block_transactions_process.rs
@@ -2,7 +2,7 @@ use crate::relayer::block_transactions_verifier::BlockTransactionsVerifier;
 use crate::relayer::block_uncles_verifier::BlockUnclesVerifier;
 use crate::relayer::{ReconstructionResult, Relayer};
 use crate::utils::send_message_to;
-use crate::{attempt, Status, StatusCode};
+use crate::{Status, StatusCode, attempt};
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_types::{core, packed, prelude::*};
 use std::collections::hash_map::Entry;
diff --git a/sync/src/relayer/compact_block_process.rs b/sync/src/relayer/compact_block_process.rs
index b46dcca1ef..5abe1053db 100644
--- a/sync/src/relayer/compact_block_process.rs
+++ b/sync/src/relayer/compact_block_process.rs
@@ -1,9 +1,9 @@
+use crate::SyncShared;
 use crate::relayer::compact_block_verifier::CompactBlockVerifier;
 use crate::relayer::{ReconstructionResult, Relayer};
 use crate::types::{ActiveChain, PendingCompactBlockMap};
 use crate::utils::send_message_to;
-use crate::SyncShared;
-use crate::{attempt, Status, StatusCode};
+use crate::{Status, StatusCode, attempt};
 use ckb_chain_spec::consensus::Consensus;
 use ckb_logger::{self, debug_target};
 use ckb_network::{CKBProtocolContext, PeerIndex};
@@ -16,8 +16,8 @@ use ckb_types::{
     packed::{self, Byte32, CompactBlock},
     prelude::*,
 };
-use ckb_util::shrink_to_fit;
 use ckb_util::MutexGuard;
+use ckb_util::shrink_to_fit;
 use ckb_verification::{HeaderError, HeaderVerifier};
 use ckb_verification_traits::Verifier;
 use std::collections::HashMap;
diff --git a/sync/src/relayer/compact_block_verifier.rs b/sync/src/relayer/compact_block_verifier.rs
index 549735c1cb..879f4f94a2 100644
--- a/sync/src/relayer/compact_block_verifier.rs
+++ b/sync/src/relayer/compact_block_verifier.rs
@@ -1,4 +1,4 @@
-use crate::{attempt, Status, StatusCode};
+use crate::{Status, StatusCode, attempt};
 use ckb_types::{packed, prelude::*};
 use std::collections::HashSet;
 
diff --git a/sync/src/relayer/get_block_proposal_process.rs b/sync/src/relayer/get_block_proposal_process.rs
index b7321ba1c3..804b937e2b 100644
--- a/sync/src/relayer/get_block_proposal_process.rs
+++ b/sync/src/relayer/get_block_proposal_process.rs
@@ -1,6 +1,6 @@
-use crate::relayer::{Relayer, MAX_RELAY_TXS_BYTES_PER_BATCH};
+use crate::relayer::{MAX_RELAY_TXS_BYTES_PER_BATCH, Relayer};
 use crate::utils::send_message_to;
-use crate::{attempt, Status, StatusCode};
+use crate::{Status, StatusCode, attempt};
 use ckb_logger::debug_target;
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_types::{packed, prelude::*};
diff --git a/sync/src/relayer/get_block_transactions_process.rs b/sync/src/relayer/get_block_transactions_process.rs
index bfff3ebc11..d12e93a311 100644
--- a/sync/src/relayer/get_block_transactions_process.rs
+++ b/sync/src/relayer/get_block_transactions_process.rs
@@ -1,6 +1,6 @@
-use crate::relayer::{Relayer, MAX_RELAY_TXS_NUM_PER_BATCH};
+use crate::relayer::{MAX_RELAY_TXS_NUM_PER_BATCH, Relayer};
 use crate::utils::send_message_to;
-use crate::{attempt, Status, StatusCode};
+use crate::{Status, StatusCode, attempt};
 use ckb_logger::debug_target;
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_store::ChainStore;
diff --git a/sync/src/relayer/get_transactions_process.rs b/sync/src/relayer/get_transactions_process.rs
index 60e8067455..71ae27e8e9 100644
--- a/sync/src/relayer/get_transactions_process.rs
+++ b/sync/src/relayer/get_transactions_process.rs
@@ -1,6 +1,6 @@
-use crate::relayer::{Relayer, MAX_RELAY_TXS_BYTES_PER_BATCH, MAX_RELAY_TXS_NUM_PER_BATCH};
+use crate::relayer::{MAX_RELAY_TXS_BYTES_PER_BATCH, MAX_RELAY_TXS_NUM_PER_BATCH, Relayer};
 use crate::utils::send_message_to;
-use crate::{attempt, Status, StatusCode};
+use crate::{Status, StatusCode, attempt};
 use ckb_logger::{debug_target, trace_target};
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_types::{packed, prelude::*};
diff --git a/sync/src/relayer/mod.rs b/sync/src/relayer/mod.rs
index 0a143e9770..9d8acd3009 100644
--- a/sync/src/relayer/mod.rs
+++ b/sync/src/relayer/mod.rs
@@ -20,8 +20,8 @@ use self::get_block_transactions_process::GetBlockTransactionsProcess;
 use self::get_transactions_process::GetTransactionsProcess;
 use self::transaction_hashes_process::TransactionHashesProcess;
 use self::transactions_process::TransactionsProcess;
-use crate::types::{post_sync_process, ActiveChain, SyncShared};
-use crate::utils::{metric_ckb_message_bytes, send_message_to, MetricDirection};
+use crate::types::{ActiveChain, SyncShared, post_sync_process};
+use crate::utils::{MetricDirection, metric_ckb_message_bytes, send_message_to};
 use crate::{Status, StatusCode};
 use ckb_chain::VerifyResult;
 use ckb_chain::{ChainController, RemoteBlock};
@@ -31,11 +31,11 @@ use ckb_logger::{
     debug, debug_target, error, error_target, info_target, trace_target, warn_target,
 };
 use ckb_network::{
-    async_trait, bytes::Bytes, tokio, CKBProtocolContext, CKBProtocolHandler, PeerIndex,
-    SupportProtocols, TargetSession,
+    CKBProtocolContext, CKBProtocolHandler, PeerIndex, SupportProtocols, TargetSession,
+    async_trait, bytes::Bytes, tokio,
 };
-use ckb_shared::block_status::BlockStatus;
 use ckb_shared::Shared;
+use ckb_shared::block_status::BlockStatus;
 use ckb_systemtime::unix_time_as_millis;
 use ckb_tx_pool::service::TxVerificationResult;
 use ckb_types::BlockNumberAndHash;
@@ -138,7 +138,7 @@ impl Relayer {
                 // before ckb2023, v3 doesn't work with relay tx
                 match RelaySwitch::new(&nc, self.v3) {
                     RelaySwitch::Ckb2023RelayV2 | RelaySwitch::Ckb2021RelayV3 => {
-                        return Status::ignored()
+                        return Status::ignored();
                     }
                     RelaySwitch::Ckb2023RelayV3 | RelaySwitch::Ckb2021RelayV2 => (),
                 }
@@ -154,7 +154,7 @@ impl Relayer {
                 // before ckb2023, v3 doesn't work with relay tx
                 match RelaySwitch::new(&nc, self.v3) {
                     RelaySwitch::Ckb2023RelayV2 | RelaySwitch::Ckb2021RelayV3 => {
-                        return Status::ignored()
+                        return Status::ignored();
                     }
                     RelaySwitch::Ckb2023RelayV3 | RelaySwitch::Ckb2021RelayV2 => (),
                 }
@@ -165,7 +165,7 @@ impl Relayer {
                 // before ckb2023, v3 doesn't work with relay tx
                 match RelaySwitch::new(&nc, self.v3) {
                     RelaySwitch::Ckb2023RelayV2 | RelaySwitch::Ckb2021RelayV3 => {
-                        return Status::ignored()
+                        return Status::ignored();
                     }
                     RelaySwitch::Ckb2023RelayV3 | RelaySwitch::Ckb2021RelayV2 => (),
                 }
@@ -324,7 +324,7 @@ impl Relayer {
                         "verify block {}-{} failed: {:?}, won't build compact block and broadcast it",
                         block.number(),
                         block.hash(),
-                            err
+                        err
                     );
 
                     let is_internal_db_error = is_internal_db_error(&err);
@@ -481,7 +481,7 @@ impl Relayer {
                 BlockStatus::BLOCK_INVALID => {
                     return ReconstructionResult::Error(
                         StatusCode::CompactBlockHasInvalidUncle.with_context(uncle_hash),
-                    )
+                    );
                 }
                 _ => missing_uncles.push(i),
             }
diff --git a/sync/src/relayer/tests/block_proposal_process.rs b/sync/src/relayer/tests/block_proposal_process.rs
index e88ec876ad..30ac47ace8 100644
--- a/sync/src/relayer/tests/block_proposal_process.rs
+++ b/sync/src/relayer/tests/block_proposal_process.rs
@@ -1,6 +1,6 @@
+use crate::Status;
 use crate::relayer::block_proposal_process::BlockProposalProcess;
 use crate::relayer::tests::helper::{build_chain, new_transaction};
-use crate::Status;
 use ckb_types::packed::{self, ProposalShortId};
 use ckb_types::prelude::*;
 
diff --git a/sync/src/relayer/tests/block_transactions_process.rs b/sync/src/relayer/tests/block_transactions_process.rs
index 8b106b7d3f..f664919ef2 100644
--- a/sync/src/relayer/tests/block_transactions_process.rs
+++ b/sync/src/relayer/tests/block_transactions_process.rs
@@ -1,5 +1,5 @@
 use crate::relayer::block_transactions_process::BlockTransactionsProcess;
-use crate::relayer::tests::helper::{build_chain, MockProtocolContext};
+use crate::relayer::tests::helper::{MockProtocolContext, build_chain};
 use crate::{Status, StatusCode};
 use ckb_network::{PeerIndex, SupportProtocols};
 use ckb_store::ChainStore;
@@ -89,10 +89,12 @@ fn test_accept_block() {
     let pending_compact_blocks = relayer.shared.state().pending_compact_blocks();
     assert!(pending_compact_blocks.get(&hash).is_none());
 
-    assert!(relayer
-        .shared
-        .state()
-        .contains_inflight_proposal(&tx3.proposal_short_id()));
+    assert!(
+        relayer
+            .shared
+            .state()
+            .contains_inflight_proposal(&tx3.proposal_short_id())
+    );
 }
 
 #[test]
diff --git a/sync/src/relayer/tests/compact_block_process.rs b/sync/src/relayer/tests/compact_block_process.rs
index 3473b8e405..a182c72fef 100644
--- a/sync/src/relayer/tests/compact_block_process.rs
+++ b/sync/src/relayer/tests/compact_block_process.rs
@@ -1,12 +1,12 @@
 use crate::relayer::compact_block_process::CompactBlockProcess;
 use crate::relayer::tests::helper::{
-    build_chain, gen_block, new_header_builder, MockProtocolContext,
+    MockProtocolContext, build_chain, gen_block, new_header_builder,
 };
 use crate::{Status, StatusCode};
 use ckb_chain::start_chain_services;
 use ckb_network::{PeerIndex, SupportProtocols};
-use ckb_shared::block_status::BlockStatus;
 use ckb_shared::ChainServicesBuilder;
+use ckb_shared::block_status::BlockStatus;
 use ckb_store::ChainStore;
 use ckb_systemtime::unix_time_as_millis;
 use ckb_tx_pool::{PlugTarget, TxEntry};
@@ -310,10 +310,12 @@ fn test_send_missing_indexes() {
         peer_index,
     );
 
-    assert!(!relayer
-        .shared
-        .state()
-        .contains_inflight_proposal(&proposal_id));
+    assert!(
+        !relayer
+            .shared
+            .state()
+            .contains_inflight_proposal(&proposal_id)
+    );
     assert_eq!(
         compact_block_process.execute(),
         StatusCode::CompactBlockRequiresFreshTransactions.into()
@@ -331,10 +333,12 @@ fn test_send_missing_indexes() {
     assert!(nc.has_sent(SupportProtocols::RelayV2.protocol_id(), peer_index, data));
 
     // insert inflight proposal
-    assert!(relayer
-        .shared
-        .state()
-        .contains_inflight_proposal(&proposal_id));
+    assert!(
+        relayer
+            .shared
+            .state()
+            .contains_inflight_proposal(&proposal_id)
+    );
 
     let content = packed::GetBlockProposal::new_builder()
         .block_hash(block.header().hash())
@@ -429,12 +433,16 @@ fn test_accept_block() {
     assert_eq!(compact_block_process.execute(), Status::ok(),);
 
     let pending_compact_blocks = relayer.shared.state().pending_compact_blocks();
-    assert!(pending_compact_blocks
-        .get(&mock_block_1.header().hash())
-        .is_none());
-    assert!(pending_compact_blocks
-        .get(&mock_block_2.header().hash())
-        .is_some());
+    assert!(
+        pending_compact_blocks
+            .get(&mock_block_1.header().hash())
+            .is_none()
+    );
+    assert!(
+        pending_compact_blocks
+            .get(&mock_block_2.header().hash())
+            .is_some()
+    );
 }
 
 #[test]
@@ -578,10 +586,12 @@ fn test_collision() {
         peer_index,
     );
 
-    assert!(!relayer
-        .shared
-        .state()
-        .contains_inflight_proposal(&proposal_id));
+    assert!(
+        !relayer
+            .shared
+            .state()
+            .contains_inflight_proposal(&proposal_id)
+    );
     assert_eq!(
         compact_block_process.execute(),
         StatusCode::CompactBlockMeetsShortIdsCollision.into(),
diff --git a/sync/src/relayer/tests/get_block_proposal_process.rs b/sync/src/relayer/tests/get_block_proposal_process.rs
index 568ba83dc7..ae23bd3b04 100644
--- a/sync/src/relayer/tests/get_block_proposal_process.rs
+++ b/sync/src/relayer/tests/get_block_proposal_process.rs
@@ -1,6 +1,6 @@
-use crate::relayer::get_block_proposal_process::GetBlockProposalProcess;
-use crate::relayer::tests::helper::{build_chain, new_transaction, MockProtocolContext};
 use crate::StatusCode;
+use crate::relayer::get_block_proposal_process::GetBlockProposalProcess;
+use crate::relayer::tests::helper::{MockProtocolContext, build_chain, new_transaction};
 use ckb_network::{PeerIndex, SupportProtocols};
 use ckb_types::packed;
 use ckb_types::prelude::*;
diff --git a/sync/src/relayer/tests/get_transactions_process.rs b/sync/src/relayer/tests/get_transactions_process.rs
index 7f38edf5ad..77b6d9251b 100644
--- a/sync/src/relayer/tests/get_transactions_process.rs
+++ b/sync/src/relayer/tests/get_transactions_process.rs
@@ -1,6 +1,6 @@
-use crate::relayer::get_transactions_process::GetTransactionsProcess;
-use crate::relayer::tests::helper::{build_chain, new_transaction, MockProtocolContext};
 use crate::StatusCode;
+use crate::relayer::get_transactions_process::GetTransactionsProcess;
+use crate::relayer::tests::helper::{MockProtocolContext, build_chain, new_transaction};
 use ckb_network::{PeerIndex, SupportProtocols};
 use ckb_types::packed;
 use ckb_types::prelude::*;
diff --git a/sync/src/relayer/tests/helper.rs b/sync/src/relayer/tests/helper.rs
index ed872ac550..df9613b1ce 100644
--- a/sync/src/relayer/tests/helper.rs
+++ b/sync/src/relayer/tests/helper.rs
@@ -1,13 +1,13 @@
 use crate::{Relayer, SyncShared};
 use ckb_app_config::NetworkConfig;
 use ckb_chain::start_chain_services;
-use ckb_chain_spec::consensus::{build_genesis_epoch_ext, ConsensusBuilder};
+use ckb_chain_spec::consensus::{ConsensusBuilder, build_genesis_epoch_ext};
 use ckb_dao::DaoCalculator;
 use ckb_dao_utils::genesis_dao_data;
 use ckb_network::{
-    async_trait, bytes::Bytes as P2pBytes, network::TransportType, Behaviour, CKBProtocolContext,
-    Error, Flags, NetworkController, NetworkService, NetworkState, Peer, PeerIndex, ProtocolId,
-    SupportProtocols, TargetSession,
+    Behaviour, CKBProtocolContext, Error, Flags, NetworkController, NetworkService, NetworkState,
+    Peer, PeerIndex, ProtocolId, SupportProtocols, TargetSession, async_trait,
+    bytes::Bytes as P2pBytes, network::TransportType,
 };
 use ckb_reward_calculator::RewardCalculator;
 use ckb_shared::{Shared, SharedBuilder, Snapshot};
@@ -15,10 +15,11 @@ use ckb_store::ChainStore;
 use ckb_systemtime::{self, unix_time_as_millis};
 use ckb_test_chain_utils::{always_success_cell, always_success_cellbase};
 use ckb_types::core::cell::resolve_transaction;
-use ckb_types::core::{capacity_bytes, BlockView, UncleBlockView};
+use ckb_types::core::{BlockView, UncleBlockView, capacity_bytes};
 use ckb_types::packed::Script;
 use ckb_types::prelude::*;
 use ckb_types::{
+    U256,
     bytes::Bytes,
     core::{
         BlockBuilder, BlockNumber, Capacity, EpochNumberWithFraction, HeaderBuilder, HeaderView,
@@ -28,7 +29,6 @@ use ckb_types::{
         CellDep, CellInput, CellOutputBuilder, IndexTransaction, IndexTransactionBuilder, OutPoint,
     },
     utilities::difficulty_to_compact,
-    U256,
 };
 use ckb_verification_traits::Switch;
 use std::collections::HashSet;
diff --git a/sync/src/relayer/tests/reconstruct_block.rs b/sync/src/relayer/tests/reconstruct_block.rs
index a7e55ec1a7..3a8d1e780d 100644
--- a/sync/src/relayer/tests/reconstruct_block.rs
+++ b/sync/src/relayer/tests/reconstruct_block.rs
@@ -1,7 +1,7 @@
 use super::helper::{build_chain, new_transaction};
-use crate::relayer::packed::{CellInput, OutPoint};
-use crate::relayer::ReconstructionResult;
 use crate::StatusCode;
+use crate::relayer::ReconstructionResult;
+use crate::relayer::packed::{CellInput, OutPoint};
 use ckb_tx_pool::{PlugTarget, TxEntry};
 use ckb_types::prelude::*;
 use ckb_types::{
diff --git a/sync/src/relayer/transaction_hashes_process.rs b/sync/src/relayer/transaction_hashes_process.rs
index 868b3dae32..377b6119f9 100644
--- a/sync/src/relayer/transaction_hashes_process.rs
+++ b/sync/src/relayer/transaction_hashes_process.rs
@@ -1,4 +1,4 @@
-use crate::relayer::{Relayer, MAX_RELAY_TXS_NUM_PER_BATCH};
+use crate::relayer::{MAX_RELAY_TXS_NUM_PER_BATCH, Relayer};
 use crate::{Status, StatusCode};
 use ckb_network::PeerIndex;
 use ckb_types::{packed, prelude::*};
diff --git a/sync/src/relayer/transactions_process.rs b/sync/src/relayer/transactions_process.rs
index 11ad489500..4e4f9ec20a 100644
--- a/sync/src/relayer/transactions_process.rs
+++ b/sync/src/relayer/transactions_process.rs
@@ -1,5 +1,5 @@
-use crate::relayer::Relayer;
 use crate::Status;
+use crate::relayer::Relayer;
 use ckb_logger::error;
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_types::{
diff --git a/sync/src/synchronizer/block_fetcher.rs b/sync/src/synchronizer/block_fetcher.rs
index 2fdebbeed4..e3fd7d6d97 100644
--- a/sync/src/synchronizer/block_fetcher.rs
+++ b/sync/src/synchronizer/block_fetcher.rs
@@ -1,5 +1,5 @@
-use crate::types::{ActiveChain, IBDState};
 use crate::SyncShared;
+use crate::types::{ActiveChain, IBDState};
 use ckb_constant::sync::{
     BLOCK_DOWNLOAD_WINDOW, CHECK_POINT_WINDOW, INIT_BLOCKS_IN_TRANSIT_PER_PEER,
 };
@@ -9,9 +9,9 @@ use ckb_network::PeerIndex;
 use ckb_shared::block_status::BlockStatus;
 use ckb_shared::types::{HeaderIndex, HeaderIndexView};
 use ckb_systemtime::unix_time_as_millis;
+use ckb_types::BlockNumberAndHash;
 use ckb_types::core::BlockNumber;
 use ckb_types::packed;
-use ckb_types::BlockNumberAndHash;
 use std::cmp::min;
 use std::sync::Arc;
 
@@ -171,11 +171,12 @@ impl BlockFetcher {
         if matches!(self.ibd, IBDState::In)
             && best_known.number() <= self.active_chain.unverified_tip_number()
         {
-            debug!("In IBD mode, Peer {}'s best_known: {} is less or equal than unverified_tip : {}, won't request block from this peer",
-                        self.peer,
-                        best_known.number(),
-                        self.active_chain.unverified_tip_number()
-                    );
+            debug!(
+                "In IBD mode, Peer {}'s best_known: {} is less or equal than unverified_tip : {}, won't request block from this peer",
+                self.peer,
+                best_known.number(),
+                self.active_chain.unverified_tip_number()
+            );
             return None;
         };
 
@@ -322,8 +323,12 @@ impl BlockFetcher {
                 self.sync_shared.shared().get_unverified_tip().number(),
                 inflight_peer_count,
                 inflight_total_count,
-                fetch.iter().map(|h| h.number().to_string()).collect::<Vec<_>>().join(","),
-                );
+                fetch
+                    .iter()
+                    .map(|h| h.number().to_string())
+                    .collect::<Vec<_>>()
+                    .join(","),
+            );
         }
 
         Some(
diff --git a/sync/src/synchronizer/block_process.rs b/sync/src/synchronizer/block_process.rs
index 074f0ac4d9..2aad02bfd2 100644
--- a/sync/src/synchronizer/block_process.rs
+++ b/sync/src/synchronizer/block_process.rs
@@ -1,6 +1,6 @@
+use crate::StatusCode;
 use crate::synchronizer::Synchronizer;
 use crate::types::post_sync_process;
-use crate::StatusCode;
 use ckb_chain::RemoteBlock;
 use ckb_error::is_internal_db_error;
 use ckb_logger::debug;
diff --git a/sync/src/synchronizer/get_blocks_process.rs b/sync/src/synchronizer/get_blocks_process.rs
index b87bb81cd8..52619e5f51 100644
--- a/sync/src/synchronizer/get_blocks_process.rs
+++ b/sync/src/synchronizer/get_blocks_process.rs
@@ -1,6 +1,6 @@
 use crate::synchronizer::Synchronizer;
 use crate::utils::send_message_to;
-use crate::{attempt, Status, StatusCode};
+use crate::{Status, StatusCode, attempt};
 use ckb_constant::sync::{INIT_BLOCKS_IN_TRANSIT_PER_PEER, MAX_HEADERS_LEN};
 use ckb_logger::debug;
 use ckb_network::{CKBProtocolContext, PeerIndex};
diff --git a/sync/src/synchronizer/get_headers_process.rs b/sync/src/synchronizer/get_headers_process.rs
index 12c5041413..79b128fb44 100644
--- a/sync/src/synchronizer/get_headers_process.rs
+++ b/sync/src/synchronizer/get_headers_process.rs
@@ -1,6 +1,6 @@
 use crate::synchronizer::Synchronizer;
 use crate::utils::{send_message, send_message_to};
-use crate::{attempt, Status, StatusCode};
+use crate::{Status, StatusCode, attempt};
 use ckb_constant::sync::MAX_LOCATOR_SIZE;
 use ckb_logger::{debug, info};
 use ckb_network::{CKBProtocolContext, PeerIndex, SupportProtocols};
diff --git a/sync/src/synchronizer/headers_process.rs b/sync/src/synchronizer/headers_process.rs
index 9fdeeb94bc..6dfd898ea6 100644
--- a/sync/src/synchronizer/headers_process.rs
+++ b/sync/src/synchronizer/headers_process.rs
@@ -3,7 +3,7 @@ use crate::types::{ActiveChain, SyncShared};
 use crate::{Status, StatusCode};
 use ckb_constant::sync::MAX_HEADERS_LEN;
 use ckb_error::Error;
-use ckb_logger::{debug, log_enabled, warn, Level};
+use ckb_logger::{Level, debug, log_enabled, warn};
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_shared::block_status::BlockStatus;
 use ckb_traits::HeaderFieldsProvider;
diff --git a/sync/src/synchronizer/mod.rs b/sync/src/synchronizer/mod.rs
index b156478fee..51e6b7f97d 100644
--- a/sync/src/synchronizer/mod.rs
+++ b/sync/src/synchronizer/mod.rs
@@ -20,14 +20,14 @@ pub(crate) use self::get_headers_process::GetHeadersProcess;
 pub(crate) use self::headers_process::HeadersProcess;
 pub(crate) use self::in_ibd_process::InIBDProcess;
 
-use crate::types::{post_sync_process, HeadersSyncController, IBDState, Peers, SyncShared};
-use crate::utils::{metric_ckb_message_bytes, send_message_to, MetricDirection};
+use crate::types::{HeadersSyncController, IBDState, Peers, SyncShared, post_sync_process};
+use crate::utils::{MetricDirection, metric_ckb_message_bytes, send_message_to};
 use crate::{Status, StatusCode};
 use ckb_shared::block_status::BlockStatus;
 
 use ckb_chain::{ChainController, RemoteBlock};
 use ckb_channel as channel;
-use ckb_channel::{select, Receiver};
+use ckb_channel::{Receiver, select};
 use ckb_constant::sync::{
     BAD_MESSAGE_BAN_TIME, CHAIN_SYNC_TIMEOUT, EVICTION_HEADERS_RESPONSE_TIME,
     INIT_BLOCKS_IN_TRANSIT_PER_PEER, MAX_TIP_AGE,
@@ -35,8 +35,8 @@ use ckb_constant::sync::{
 use ckb_logger::{debug, error, info, trace, warn};
 use ckb_metrics::HistogramTimer;
 use ckb_network::{
-    async_trait, bytes::Bytes, tokio, CKBProtocolContext, CKBProtocolHandler, PeerIndex,
-    ServiceControl, SupportProtocols,
+    CKBProtocolContext, CKBProtocolHandler, PeerIndex, ServiceControl, SupportProtocols,
+    async_trait, bytes::Bytes, tokio,
 };
 use ckb_shared::types::HeaderIndexView;
 use ckb_stop_handler::{new_crossbeam_exit_rx, register_thread};
@@ -51,7 +51,7 @@ use ckb_types::{
 };
 use std::{
     collections::HashSet,
-    sync::{atomic::Ordering, Arc},
+    sync::{Arc, atomic::Ordering},
     time::{Duration, Instant},
 };
 
@@ -125,12 +125,12 @@ impl BlockFetchCMD {
                 if number != self.number && (number - self.number) % 10000 == 0 {
                     self.number = number;
                     info!(
-                            "The current best known header number: {}, total difficulty: {:#x}. \
+                        "The current best known header number: {}, total difficulty: {:#x}. \
                                  Block download minimum requirements: header number: 500_000, total difficulty: {:#x}.",
-                            number,
-                            best_known.total_difficulty(),
-                            self.sync_shared.state().min_chain_work()
-                        );
+                        number,
+                        best_known.total_difficulty(),
+                        self.sync_shared.state().min_chain_work()
+                    );
                 }
             }
             CanStart::AssumeValidNotFound => {
@@ -262,12 +262,17 @@ impl BlockFetchCMD {
                             // BlockFetchCMD has set the fetch target, no need to set it again
                         } else {
                             *flag = CanStart::FetchToTarget(header.number());
-                            info!("assume valid target found in header_map; CKB will start fetch blocks to {:?} now", header.number_and_hash());
+                            info!(
+                                "assume valid target found in header_map; CKB will start fetch blocks to {:?} now",
+                                header.number_and_hash()
+                            );
                         }
                         // Blocks that are no longer in the scope of ibd must be forced to verify
                         if unix_time_as_millis().saturating_sub(header.timestamp()) < MAX_TIP_AGE {
                             assume_valid_targets.take();
-                            warn!("the duration gap between 'assume valid target' and 'now' is less than 24h; CKB will ignore the specified assume valid target and do full verification from now on");
+                            warn!(
+                                "the duration gap between 'assume valid target' and 'now' is less than 24h; CKB will ignore the specified assume valid target and do full verification from now on"
+                            );
                         }
                     }
                     None => {
@@ -276,7 +281,9 @@ impl BlockFetchCMD {
                             .saturating_sub(state.shared_best_header_ref().timestamp())
                             < MAX_TIP_AGE
                         {
-                            warn!("the duration gap between 'shared_best_header' and 'now' is less than 24h, but CKB haven't found the assume valid target in header_map; CKB will ignore the specified assume valid target and do full verification from now on");
+                            warn!(
+                                "the duration gap between 'shared_best_header' and 'now' is less than 24h, but CKB haven't found the assume valid target in header_map; CKB will ignore the specified assume valid target and do full verification from now on"
+                            );
                             *flag = CanStart::Ready;
                             assume_valid_targets.take();
                         }
@@ -638,11 +645,7 @@ impl Synchronizer {
                 .state()
                 .n_sync_started()
                 .fetch_update(Ordering::AcqRel, Ordering::Acquire, |x| {
-                    if ibd && x != 0 {
-                        None
-                    } else {
-                        Some(x + 1)
-                    }
+                    if ibd && x != 0 { None } else { Some(x + 1) }
                 })
                 .is_err()
             {
diff --git a/sync/src/tests/inflight_blocks.rs b/sync/src/tests/inflight_blocks.rs
index 4511a85821..692b0ce44c 100644
--- a/sync/src/tests/inflight_blocks.rs
+++ b/sync/src/tests/inflight_blocks.rs
@@ -1,8 +1,8 @@
 use crate::types::InflightBlocks;
 use ckb_constant::sync::BLOCK_DOWNLOAD_TIMEOUT;
+use ckb_types::BlockNumberAndHash;
 use ckb_types::h256;
 use ckb_types::prelude::*;
-use ckb_types::BlockNumberAndHash;
 use std::collections::HashSet;
 
 #[test]
@@ -186,12 +186,16 @@ fn inflight_trace_number_state() {
 
     assert!(inflight_blocks.restart_number == 3);
 
-    assert!(inflight_blocks
-        .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
-        .is_none());
-    assert!(inflight_blocks
-        .inflight_state_by_block(&(3, h256!("0x33").pack()).into())
-        .is_none());
+    assert!(
+        inflight_blocks
+            .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
+            .is_none()
+    );
+    assert!(
+        inflight_blocks
+            .inflight_state_by_block(&(3, h256!("0x33").pack()).into())
+            .is_none()
+    );
 
     assert_eq!(inflight_blocks.peer_can_fetch_count(3.into()), 32 >> 1);
     assert_eq!(inflight_blocks.peer_can_fetch_count(4.into()), 32 >> 1);
diff --git a/sync/src/tests/mod.rs b/sync/src/tests/mod.rs
index cb6d1ab347..c85918c5a9 100644
--- a/sync/src/tests/mod.rs
+++ b/sync/src/tests/mod.rs
@@ -1,8 +1,8 @@
-use ckb_channel::{bounded, Receiver, Select, Sender};
+use ckb_channel::{Receiver, Select, Sender, bounded};
 use ckb_network::async_trait;
 use ckb_network::{
-    bytes::Bytes, Behaviour, CKBProtocolContext, CKBProtocolHandler, Peer, PeerIndex, ProtocolId,
-    TargetSession,
+    Behaviour, CKBProtocolContext, CKBProtocolHandler, Peer, PeerIndex, ProtocolId, TargetSession,
+    bytes::Bytes,
 };
 use ckb_util::RwLock;
 use futures::{executor::block_on, future::Future};
@@ -213,9 +213,11 @@ impl CKBProtocolContext for TestNetworkContext {
         let index = Index::Timer(self.protocol, token);
         if let Some(sender) = self.senders.get(&index) {
             let sender = sender.clone();
-            thread::spawn(move || loop {
-                thread::sleep(interval);
-                let _ = sender.send(Msg::Empty);
+            thread::spawn(move || {
+                loop {
+                    thread::sleep(interval);
+                    let _ = sender.send(Msg::Empty);
+                }
             });
         }
         Ok(())
diff --git a/sync/src/tests/net_time_checker.rs b/sync/src/tests/net_time_checker.rs
index 89d631d5ee..9b90968328 100644
--- a/sync/src/tests/net_time_checker.rs
+++ b/sync/src/tests/net_time_checker.rs
@@ -1,9 +1,9 @@
 use crate::net_time_checker::{NetTimeChecker, NetTimeProtocol, TOLERANT_OFFSET};
 use ckb_app_config::NetworkConfig;
 use ckb_network::{
-    multiaddr::{Multiaddr, Protocol},
     CKBProtocol, EventHandler, NetworkState, ServiceBuilder, ServiceControl, SessionId,
     SupportProtocols, TargetProtocol,
+    multiaddr::{Multiaddr, Protocol},
 };
 use std::{
     borrow::Cow,
diff --git a/sync/src/tests/sync_shared.rs b/sync/src/tests/sync_shared.rs
index da9dea6e83..8f52cc0f19 100644
--- a/sync/src/tests/sync_shared.rs
+++ b/sync/src/tests/sync_shared.rs
@@ -1,12 +1,12 @@
 #![allow(unused_imports)]
 #![allow(dead_code)]
 
-use crate::relayer::tests::helper::MockProtocolContext;
 use crate::relayer::CompactBlockProcess;
+use crate::relayer::tests::helper::MockProtocolContext;
 use crate::synchronizer::HeadersProcess;
 use crate::tests::util::{build_chain, inherit_block};
 use crate::{Relayer, Status, SyncShared, Synchronizer};
-use ckb_chain::{start_chain_services, RemoteBlock, VerifyResult};
+use ckb_chain::{RemoteBlock, VerifyResult, start_chain_services};
 use ckb_logger::info;
 use ckb_shared::block_status::BlockStatus;
 use ckb_shared::{Shared, SharedBuilder};
@@ -44,12 +44,16 @@ fn test_insert_new_block() {
         Arc::new(next_block)
     };
 
-    assert!(shared
-        .blocking_insert_new_block(&chain, Arc::clone(&new_block))
-        .expect("insert valid block"));
-    assert!(!shared
-        .blocking_insert_new_block(&chain, Arc::clone(&new_block))
-        .expect("insert duplicated valid block"),);
+    assert!(
+        shared
+            .blocking_insert_new_block(&chain, Arc::clone(&new_block))
+            .expect("insert valid block")
+    );
+    assert!(
+        !shared
+            .blocking_insert_new_block(&chain, Arc::clone(&new_block))
+            .expect("insert duplicated valid block"),
+    );
 }
 
 #[test]
@@ -67,9 +71,11 @@ fn test_insert_invalid_block() {
         Arc::new(next_block)
     };
 
-    assert!(shared
-        .blocking_insert_new_block(&chain, Arc::clone(&invalid_block))
-        .is_err(),);
+    assert!(
+        shared
+            .blocking_insert_new_block(&chain, Arc::clone(&invalid_block))
+            .is_err(),
+    );
 }
 
 #[test]
@@ -157,9 +163,11 @@ fn test_insert_parent_unknown_block() {
 
     // After inserting parent of an orphan block
 
-    assert!(shared
-        .blocking_insert_new_block(&chain, Arc::clone(&parent))
-        .expect("insert parent of orphan block"));
+    assert!(
+        shared
+            .blocking_insert_new_block(&chain, Arc::clone(&parent))
+            .expect("insert parent of orphan block")
+    );
 
     assert!(wait_for_block_status_match(
         &valid_hash,
@@ -225,9 +233,11 @@ fn test_insert_child_block_with_stored_but_unverified_parent() {
         )
     };
 
-    assert!(shared
-        .blocking_insert_new_block(&chain, Arc::clone(&child))
-        .expect("insert child block"));
+    assert!(
+        shared
+            .blocking_insert_new_block(&chain, Arc::clone(&child))
+            .expect("insert child block")
+    );
 
     assert!(wait_for_expected_block_status(
         &shared,
@@ -259,12 +269,16 @@ fn test_switch_valid_fork() {
             .timestamp((parent_header.timestamp() + 3).pack())
             .build();
         let arc_block = Arc::new(block.clone());
-        assert!(fork_shared
-            .blocking_insert_new_block(&fork_chain, Arc::clone(&arc_block))
-            .expect("insert fork"),);
-        assert!(shared
-            .blocking_insert_new_block(&chain, arc_block)
-            .expect("insert fork"),);
+        assert!(
+            fork_shared
+                .blocking_insert_new_block(&fork_chain, Arc::clone(&arc_block))
+                .expect("insert fork"),
+        );
+        assert!(
+            shared
+                .blocking_insert_new_block(&chain, arc_block)
+                .expect("insert fork"),
+        );
         parent_header = block.header().clone();
         valid_fork.push(block);
     }
@@ -284,12 +298,16 @@ fn test_switch_valid_fork() {
             .timestamp((parent_header.timestamp() + 3).pack())
             .build();
         let arc_block = Arc::new(block.clone());
-        assert!(fork_shared
-            .blocking_insert_new_block(&fork_chain, Arc::clone(&arc_block))
-            .expect("insert fork"),);
-        assert!(shared
-            .blocking_insert_new_block(&chain, arc_block)
-            .expect("insert fork"),);
+        assert!(
+            fork_shared
+                .blocking_insert_new_block(&fork_chain, Arc::clone(&arc_block))
+                .expect("insert fork"),
+        );
+        assert!(
+            shared
+                .blocking_insert_new_block(&chain, arc_block)
+                .expect("insert fork"),
+        );
         parent_header = block.header().clone();
         valid_fork.push(block);
     }
diff --git a/sync/src/tests/synchronizer/basic_sync.rs b/sync/src/tests/synchronizer/basic_sync.rs
index 1eaa2c3bc9..e6a2945c9d 100644
--- a/sync/src/tests/synchronizer/basic_sync.rs
+++ b/sync/src/tests/synchronizer/basic_sync.rs
@@ -18,11 +18,11 @@ use ckb_systemtime::{self, unix_time_as_millis};
 use ckb_test_chain_utils::always_success_cell;
 use ckb_types::prelude::*;
 use ckb_types::{
+    U256,
     bytes::Bytes,
-    core::{cell::resolve_transaction, BlockBuilder, EpochNumberWithFraction, TransactionBuilder},
+    core::{BlockBuilder, EpochNumberWithFraction, TransactionBuilder, cell::resolve_transaction},
     packed::{self, CellInput, CellOutputBuilder, OutPoint},
     utilities::difficulty_to_compact,
-    U256,
 };
 use ckb_util::RwLock;
 use ckb_verification_traits::Switch;
diff --git a/sync/src/tests/synchronizer/functions.rs b/sync/src/tests/synchronizer/functions.rs
index 19f23b06d3..e64a1ab75a 100644
--- a/sync/src/tests/synchronizer/functions.rs
+++ b/sync/src/tests/synchronizer/functions.rs
@@ -1,11 +1,11 @@
-use ckb_chain::{start_chain_services, ChainController};
+use ckb_chain::{ChainController, start_chain_services};
 use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_constant::sync::{CHAIN_SYNC_TIMEOUT, EVICTION_HEADERS_RESPONSE_TIME, MAX_TIP_AGE};
 use ckb_dao::DaoCalculator;
 use ckb_error::InternalErrorKind;
 use ckb_network::{
-    async_trait, bytes::Bytes, Behaviour, CKBProtocolContext, Peer, PeerId, PeerIndex, ProtocolId,
-    SessionType, TargetSession,
+    Behaviour, CKBProtocolContext, Peer, PeerId, PeerIndex, ProtocolId, SessionType, TargetSession,
+    async_trait, bytes::Bytes,
 };
 use ckb_reward_calculator::RewardCalculator;
 use ckb_shared::types::HeaderIndex;
@@ -13,16 +13,16 @@ use ckb_shared::{Shared, SharedBuilder, Snapshot};
 use ckb_store::ChainStore;
 use ckb_systemtime::unix_time_as_millis;
 use ckb_types::{
+    U256,
     core::{
-        cell::resolve_transaction, BlockBuilder, BlockNumber, BlockView, EpochExt, HeaderView,
-        TransactionBuilder, TransactionView,
+        BlockBuilder, BlockNumber, BlockView, EpochExt, HeaderView, TransactionBuilder,
+        TransactionView, cell::resolve_transaction,
     },
     packed::{
         self, Byte32, CellInput, CellOutputBuilder, Script, SendBlockBuilder, SendHeadersBuilder,
     },
     prelude::*,
     utilities::difficulty_to_compact,
-    U256,
 };
 use ckb_util::Mutex;
 use ckb_verification_traits::Switch;
@@ -31,14 +31,14 @@ use std::{
     collections::{HashMap, HashSet},
     ops::Deref,
     pin::Pin,
-    sync::{atomic::Ordering, Arc},
+    sync::{Arc, atomic::Ordering},
     time::Duration,
 };
 
 use crate::{
+    Status, StatusCode, SyncShared,
     synchronizer::{BlockFetcher, BlockProcess, GetBlocksProcess, HeadersProcess, Synchronizer},
     types::{HeadersSyncController, IBDState, PeerState},
-    Status, StatusCode, SyncShared,
 };
 
 fn start_chain(consensus: Option<Consensus>) -> (ChainController, Shared, Synchronizer) {
@@ -718,10 +718,12 @@ fn test_header_sync_timeout() {
     let network_context = mock_network_context(5);
 
     _faketime_guard.set_faketime(MAX_TIP_AGE * 2);
-    assert!(synchronizer
-        .shared
-        .active_chain()
-        .is_initial_block_download());
+    assert!(
+        synchronizer
+            .shared
+            .active_chain()
+            .is_initial_block_download()
+    );
     let peers = synchronizer.peers();
     // protect should not effect headers_timeout
     {
@@ -841,11 +843,13 @@ fn test_chain_sync_timeout() {
     synchronizer.eviction(&network_context);
     {
         // Protected peer 0 still in sync state
-        assert!(peers
-            .state
-            .get(&sync_protected_peer)
-            .unwrap()
-            .sync_started(),);
+        assert!(
+            peers
+                .state
+                .get(&sync_protected_peer)
+                .unwrap()
+                .sync_started(),
+        );
         assert_eq!(
             synchronizer
                 .shared()
@@ -858,13 +862,15 @@ fn test_chain_sync_timeout() {
         assert!({ network_context.disconnected.lock().is_empty() });
         // start sync with protected peer
         //protect peer is protected from disconnection
-        assert!(peers
-            .state
-            .get(&2.into())
-            .unwrap()
-            .chain_sync
-            .work_header
-            .is_none());
+        assert!(
+            peers
+                .state
+                .get(&2.into())
+                .unwrap()
+                .chain_sync
+                .work_header
+                .is_none()
+        );
         // Our best block known by this peer is behind our tip, and we're either noticing
         // that for the first time, OR this peer was able to catch up to some earlier point
         // where we checked against our tip.
@@ -933,11 +939,13 @@ fn test_chain_sync_timeout() {
     synchronizer.eviction(&network_context);
     {
         // Protected peer 0 chain_sync timeout
-        assert!(!peers
-            .state
-            .get(&sync_protected_peer)
-            .unwrap()
-            .sync_started(),);
+        assert!(
+            !peers
+                .state
+                .get(&sync_protected_peer)
+                .unwrap()
+                .sync_started(),
+        );
         assert_eq!(
             synchronizer
                 .shared()
@@ -1023,11 +1031,13 @@ fn test_n_sync_started() {
     synchronizer.eviction(&network_context);
     {
         // Protected peer 0 chain_sync timeout
-        assert!(!peers
-            .state
-            .get(&sync_protected_peer)
-            .unwrap()
-            .sync_started(),);
+        assert!(
+            !peers
+                .state
+                .get(&sync_protected_peer)
+                .unwrap()
+                .sync_started(),
+        );
         assert_eq!(
             synchronizer
                 .shared()
diff --git a/sync/src/tests/types.rs b/sync/src/tests/types.rs
index e41c0827d1..d3ae546d3b 100644
--- a/sync/src/tests/types.rs
+++ b/sync/src/tests/types.rs
@@ -1,11 +1,11 @@
 use ckb_shared::types::HeaderIndexView;
 use ckb_types::{
+    U256,
     core::{BlockNumber, EpochNumberWithFraction, HeaderBuilder},
     packed::Byte32,
     prelude::*,
-    U256,
 };
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 use std::{
     collections::{BTreeMap, HashMap},
     sync::atomic::{
@@ -14,7 +14,7 @@ use std::{
     },
 };
 
-use crate::types::{TtlFilter, FILTER_TTL};
+use crate::types::{FILTER_TTL, TtlFilter};
 
 const SKIPLIST_LENGTH: u64 = 10_000;
 
diff --git a/sync/src/tests/util.rs b/sync/src/tests/util.rs
index 8f37b7e7bf..02f6a1e8d0 100644
--- a/sync/src/tests/util.rs
+++ b/sync/src/tests/util.rs
@@ -1,5 +1,5 @@
 use crate::SyncShared;
-use ckb_chain::{start_chain_services, ChainController};
+use ckb_chain::{ChainController, start_chain_services};
 use ckb_dao::DaoCalculator;
 use ckb_reward_calculator::RewardCalculator;
 use ckb_shared::{Shared, SharedBuilder, Snapshot};
@@ -7,7 +7,7 @@ use ckb_store::ChainStore;
 use ckb_test_chain_utils::{always_success_cellbase, always_success_consensus};
 use ckb_types::prelude::*;
 use ckb_types::{
-    core::{cell::resolve_transaction, BlockBuilder, BlockNumber, TransactionView},
+    core::{BlockBuilder, BlockNumber, TransactionView, cell::resolve_transaction},
     packed::Byte32,
 };
 use ckb_verification_traits::Switch;
diff --git a/sync/src/types/mod.rs b/sync/src/types/mod.rs
index 476a5c308b..790deb662c 100644
--- a/sync/src/types/mod.rs
+++ b/sync/src/types/mod.rs
@@ -1,4 +1,4 @@
-use crate::{Status, StatusCode, FAST_INDEX, LOW_INDEX, NORMAL_INDEX, TIME_TRACE_SIZE};
+use crate::{FAST_INDEX, LOW_INDEX, NORMAL_INDEX, Status, StatusCode, TIME_TRACE_SIZE};
 use ckb_app_config::SyncConfig;
 #[cfg(test)]
 use ckb_chain::VerifyResult;
@@ -15,10 +15,10 @@ use ckb_constant::sync::{
 use ckb_logger::{debug, error, info, trace, warn};
 use ckb_network::{CKBProtocolContext, PeerIndex, SupportProtocols};
 use ckb_shared::{
+    Snapshot,
     block_status::BlockStatus,
     shared::Shared,
     types::{HeaderIndex, HeaderIndexView, SHRINK_THRESHOLD},
-    Snapshot,
 };
 use ckb_store::{ChainDB, ChainStore};
 use ckb_systemtime::unix_time_as_millis;
@@ -26,19 +26,19 @@ use ckb_traits::{HeaderFields, HeaderFieldsProvider};
 use ckb_tx_pool::service::TxVerificationResult;
 use ckb_types::BlockNumberAndHash;
 use ckb_types::{
+    U256,
     core::{self, BlockNumber, EpochExt},
     packed::{self, Byte32},
     prelude::*,
-    U256,
 };
-use ckb_util::{shrink_to_fit, Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};
+use ckb_util::{Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard, shrink_to_fit};
 use dashmap::{self, DashMap};
 use keyed_priority_queue::{self, KeyedPriorityQueue};
 use lru::LruCache;
-use std::collections::{btree_map::Entry, BTreeMap, HashMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet, btree_map::Entry};
 use std::hash::Hash;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::{Duration, Instant};
 use std::{cmp, fmt, iter};
 
@@ -1972,11 +1972,7 @@ pub enum IBDState {
 
 impl From<bool> for IBDState {
     fn from(src: bool) -> Self {
-        if src {
-            IBDState::In
-        } else {
-            IBDState::Out
-        }
+        if src { IBDState::In } else { IBDState::Out }
     }
 }
 
diff --git a/test/src/lib.rs b/test/src/lib.rs
index 58b98b743b..ec85c1e892 100644
--- a/test/src/lib.rs
+++ b/test/src/lib.rs
@@ -17,7 +17,7 @@ use ckb_types::core::BlockNumber;
 pub use net::Net;
 pub use node::Node;
 pub use specs::{Setup, Spec};
-pub use txo::{TXOSet, TXO};
+pub use txo::{TXO, TXOSet};
 
 // ckb doesn't support tx proposal window configuration, use a hardcoded value for integration test.
 pub const DEFAULT_TX_PROPOSAL_WINDOW: (BlockNumber, BlockNumber) = (2, 10);
diff --git a/test/src/main.rs b/test/src/main.rs
index d19c222659..c3d4751365 100644
--- a/test/src/main.rs
+++ b/test/src/main.rs
@@ -2,9 +2,9 @@ use ckb_channel::unbounded;
 use ckb_logger::{error, info, warn};
 use ckb_test::specs::*;
 use ckb_test::{
+    Spec,
     global::{self, BINARY_PATH, PORT_COUNTER, VENDOR_PATH},
     worker::{Notify, Workers},
-    Spec,
 };
 use ckb_types::core::ScriptHashType;
 use ckb_util::Mutex;
@@ -14,11 +14,11 @@ use std::any::Any;
 use std::cmp::min;
 use std::collections::HashSet;
 use std::env;
-use std::fs::{self, read_to_string, File};
+use std::fs::{self, File, read_to_string};
 use std::io::{self, BufRead, BufReader, Write};
 use std::path::{Path, PathBuf};
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 use std::time::{Duration, Instant};
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
diff --git a/test/src/net.rs b/test/src/net.rs
index a1de238d0b..8e5cc3c964 100644
--- a/test/src/net.rs
+++ b/test/src/net.rs
@@ -1,14 +1,14 @@
-use crate::utils::{find_available_port, message_name, temp_path, wait_until};
 use crate::Node;
+use crate::utils::{find_available_port, message_name, temp_path, wait_until};
 use ckb_app_config::NetworkConfig;
-use ckb_async_runtime::{new_global_runtime, Runtime};
+use ckb_async_runtime::{Runtime, new_global_runtime};
 use ckb_chain_spec::consensus::Consensus;
-use ckb_channel::{self as channel, unbounded, Receiver, RecvTimeoutError, Sender};
+use ckb_channel::{self as channel, Receiver, RecvTimeoutError, Sender, unbounded};
 use ckb_logger::info;
 use ckb_network::{
-    async_trait, bytes::Bytes, extract_peer_id, network::TransportType, CKBProtocol,
-    CKBProtocolContext, CKBProtocolHandler, Flags, NetworkController, NetworkService, NetworkState,
-    PeerIndex, ProtocolId, SupportProtocols,
+    CKBProtocol, CKBProtocolContext, CKBProtocolHandler, Flags, NetworkController, NetworkService,
+    NetworkState, PeerIndex, ProtocolId, SupportProtocols, async_trait, bytes::Bytes,
+    extract_peer_id, network::TransportType,
 };
 use ckb_util::Mutex;
 use std::collections::HashMap;
diff --git a/test/src/node.rs b/test/src/node.rs
index 24b511f263..4d1fa6708f 100644
--- a/test/src/node.rs
+++ b/test/src/node.rs
@@ -3,8 +3,8 @@ use crate::rpc::RpcClient;
 use crate::utils::{find_available_port, temp_path, wait_until};
 use crate::{SYSTEM_CELL_ALWAYS_FAILURE_INDEX, SYSTEM_CELL_ALWAYS_SUCCESS_INDEX};
 use ckb_app_config::{AppConfig, CKBAppConfig, ExitCode};
-use ckb_chain_spec::consensus::Consensus;
 use ckb_chain_spec::ChainSpec;
+use ckb_chain_spec::consensus::Consensus;
 use ckb_error::AnyError;
 use ckb_jsonrpc_types::{BlockFilter, BlockTemplate, TxPoolInfo};
 use ckb_jsonrpc_types::{PoolTxDetailInfo, TxStatus};
@@ -16,8 +16,8 @@ use ckb_store::ChainDB;
 use ckb_types::{
     bytes,
     core::{
-        self, capacity_bytes, BlockBuilder, BlockNumber, BlockView, Capacity, HeaderView,
-        ScriptHashType, TransactionView,
+        self, BlockBuilder, BlockNumber, BlockView, Capacity, HeaderView, ScriptHashType,
+        TransactionView, capacity_bytes,
     },
     packed::{Block, Byte32, CellDep, CellInput, CellOutput, CellOutputBuilder, OutPoint, Script},
     prelude::*,
diff --git a/test/src/rpc.rs b/test/src/rpc.rs
index 0cafcbe572..6b8ca35196 100644
--- a/test/src/rpc.rs
+++ b/test/src/rpc.rs
@@ -15,7 +15,7 @@ use ckb_types::core::{
     BlockNumber as CoreBlockNumber, Capacity as CoreCapacity, EpochNumber as CoreEpochNumber,
     Version as CoreVersion,
 };
-use ckb_types::{packed::Byte32, prelude::*, H256};
+use ckb_types::{H256, packed::Byte32, prelude::*};
 
 pub static HTTP_CLIENT: std::sync::LazyLock<reqwest::blocking::Client> =
     std::sync::LazyLock::new(|| {
diff --git a/test/src/specs/alert/mod.rs b/test/src/specs/alert/mod.rs
index 3b8152b6e3..80789d184c 100644
--- a/test/src/specs/alert/mod.rs
+++ b/test/src/specs/alert/mod.rs
@@ -5,7 +5,7 @@ pub use alert_propagation::*;
 use ckb_app_config::NetworkAlertConfig;
 use ckb_crypto::secp::Privkey;
 use ckb_jsonrpc_types::JsonBytes;
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 
 pub(crate) fn random_privkey() -> Privkey {
     let mut rng = thread_rng();
diff --git a/test/src/specs/consensus/insufficient_reward.rs b/test/src/specs/consensus/insufficient_reward.rs
index 45d1e6bf3d..b49e764aec 100644
--- a/test/src/specs/consensus/insufficient_reward.rs
+++ b/test/src/specs/consensus/insufficient_reward.rs
@@ -3,7 +3,7 @@ use crate::specs::spec_name;
 use crate::{Node, Spec};
 
 use ckb_types::{
-    core::{capacity_bytes, Capacity},
+    core::{Capacity, capacity_bytes},
     packed::CellOutput,
     prelude::*,
 };
diff --git a/test/src/specs/dao/dao_user.rs b/test/src/specs/dao/dao_user.rs
index aa729e8476..c5af634767 100644
--- a/test/src/specs/dao/dao_user.rs
+++ b/test/src/specs/dao/dao_user.rs
@@ -1,5 +1,5 @@
 use crate::utils::since_from_absolute_epoch_number;
-use crate::{Node, TXOSet, TXO};
+use crate::{Node, TXO, TXOSet};
 use ckb_chain_spec::OUTPUT_INDEX_DAO;
 use ckb_types::core::{EpochNumberWithFraction, HeaderView};
 use ckb_types::packed::WitnessArgs;
diff --git a/test/src/specs/dao/satoshi_dao_occupied.rs b/test/src/specs/dao/satoshi_dao_occupied.rs
index 5756d25ceb..da580db59a 100644
--- a/test/src/specs/dao/satoshi_dao_occupied.rs
+++ b/test/src/specs/dao/satoshi_dao_occupied.rs
@@ -11,11 +11,11 @@ use ckb_test_chain_utils::always_success_cell;
 use ckb_types::core::{EpochNumberWithFraction, TransactionBuilder};
 use ckb_types::packed::{CellInput, CellOutput, OutPoint};
 use ckb_types::{
+    H160,
     bytes::Bytes,
     core::{Capacity, Ratio},
     h160,
     prelude::*,
-    H160,
 };
 
 const SATOSHI_CELL_CAPACITY: Capacity = Capacity::shannons(10_000_000_000_000_000);
diff --git a/test/src/specs/dao/utils.rs b/test/src/specs/dao/utils.rs
index 331aaea5e0..c63a59a9c1 100644
--- a/test/src/specs/dao/utils.rs
+++ b/test/src/specs/dao/utils.rs
@@ -1,5 +1,5 @@
-use crate::util::check::is_transaction_committed;
 use crate::Node;
+use crate::util::check::is_transaction_committed;
 use ckb_types::core::EpochNumberWithFraction;
 use ckb_types::{core::TransactionView, packed::OutPoint};
 
diff --git a/test/src/specs/fault_injection/randomly_kill.rs b/test/src/specs/fault_injection/randomly_kill.rs
index e3f42a67d0..859e84fb60 100644
--- a/test/src/specs/fault_injection/randomly_kill.rs
+++ b/test/src/specs/fault_injection/randomly_kill.rs
@@ -1,7 +1,7 @@
 use crate::{Node, Spec};
 
 use ckb_logger::info;
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 
 pub struct RandomlyKill;
 
diff --git a/test/src/specs/hardfork/v2021/cell_deps.rs b/test/src/specs/hardfork/v2021/cell_deps.rs
index 929a2e2f54..c50862c34d 100644
--- a/test/src/specs/hardfork/v2021/cell_deps.rs
+++ b/test/src/specs/hardfork/v2021/cell_deps.rs
@@ -1,10 +1,10 @@
 use crate::{
+    Node, Spec,
     util::{
         cell::gen_spendable,
         check::{assert_epoch_should_greater_than, is_transaction_committed},
     },
     utils::assert_send_transaction_fail,
-    Node, Spec,
 };
 use ckb_jsonrpc_types as rpc;
 use ckb_jsonrpc_types::Either;
diff --git a/test/src/specs/hardfork/v2021/vm_b_extension.rs b/test/src/specs/hardfork/v2021/vm_b_extension.rs
index 22882c4140..106874470f 100644
--- a/test/src/specs/hardfork/v2021/vm_b_extension.rs
+++ b/test/src/specs/hardfork/v2021/vm_b_extension.rs
@@ -1,7 +1,7 @@
 use crate::{
+    Node, Spec,
     util::{cell::gen_spendable, check::is_transaction_committed},
     utils::assert_send_transaction_fail,
-    Node, Spec,
 };
 use ckb_logger::{debug, info};
 use ckb_types::{
diff --git a/test/src/specs/hardfork/v2021/vm_version1.rs b/test/src/specs/hardfork/v2021/vm_version1.rs
index f49d955275..6d4330822d 100644
--- a/test/src/specs/hardfork/v2021/vm_version1.rs
+++ b/test/src/specs/hardfork/v2021/vm_version1.rs
@@ -1,7 +1,7 @@
 use crate::{
+    Node, Spec,
     util::{cell::gen_spendable, check::is_transaction_committed},
     utils::{assert_send_transaction_fail, wait_until},
-    Node, Spec,
 };
 use ckb_jsonrpc_types as rpc;
 use ckb_jsonrpc_types::Either;
diff --git a/test/src/specs/hardfork/v2023/vm_version2.rs b/test/src/specs/hardfork/v2023/vm_version2.rs
index 972fb74f9e..e00730121f 100644
--- a/test/src/specs/hardfork/v2023/vm_version2.rs
+++ b/test/src/specs/hardfork/v2023/vm_version2.rs
@@ -1,10 +1,10 @@
 use crate::{
+    Node, Spec,
     util::{
         cell::gen_spendable,
         check::{assert_epoch_should_less_than, is_transaction_committed},
     },
     utils::{assert_send_transaction_fail, wait_until},
-    Node, Spec,
 };
 use ckb_jsonrpc_types as rpc;
 use ckb_jsonrpc_types::Either;
diff --git a/test/src/specs/mining/bootstrap.rs b/test/src/specs/mining/bootstrap.rs
index 0bf13bbfcd..ffb07c30a9 100644
--- a/test/src/specs/mining/bootstrap.rs
+++ b/test/src/specs/mining/bootstrap.rs
@@ -1,4 +1,4 @@
-use crate::{Node, Spec, DEFAULT_TX_PROPOSAL_WINDOW};
+use crate::{DEFAULT_TX_PROPOSAL_WINDOW, Node, Spec};
 use ckb_app_config::BlockAssemblerConfig;
 use ckb_jsonrpc_types::JsonBytes;
 use ckb_types::{
diff --git a/test/src/specs/mining/fee.rs b/test/src/specs/mining/fee.rs
index 4f9d2d8b26..7874eaa09f 100644
--- a/test/src/specs/mining/fee.rs
+++ b/test/src/specs/mining/fee.rs
@@ -3,18 +3,18 @@ use crate::generic::{GetCommitTxIds, GetProposalTxIds};
 use crate::util::cell::{as_input, gen_spendable};
 use crate::util::check::is_transaction_committed;
 use crate::util::transaction::always_success_transaction;
-use crate::{Node, Spec};
 use crate::{DEFAULT_TX_PROPOSAL_WINDOW, FINALIZATION_DELAY_LENGTH};
+use crate::{Node, Spec};
 use ckb_types::core::TransactionBuilder;
 use ckb_types::packed::CellInput;
 use ckb_types::packed::CellOutput;
 use ckb_types::packed::OutPoint;
 use ckb_types::prelude::*;
 use ckb_types::{
-    core::{capacity_bytes, Capacity},
+    core::{Capacity, capacity_bytes},
     packed::CellOutputBuilder,
 };
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 
 pub struct FeeOfTransaction;
 
diff --git a/test/src/specs/p2p/malformed_message.rs b/test/src/specs/p2p/malformed_message.rs
index c58807451d..cf515ad1e7 100644
--- a/test/src/specs/p2p/malformed_message.rs
+++ b/test/src/specs/p2p/malformed_message.rs
@@ -2,7 +2,7 @@ use crate::util::mining::out_ibd_mode;
 use crate::utils::{sleep, wait_until};
 use crate::{Net, Node, Spec};
 use ckb_logger::info;
-use ckb_network::{bytes::Bytes, SupportProtocols};
+use ckb_network::{SupportProtocols, bytes::Bytes};
 use ckb_types::{
     packed::{GetHeaders, SyncMessage},
     prelude::*,
diff --git a/test/src/specs/relay/compact_block.rs b/test/src/specs/relay/compact_block.rs
index 9b8c078b7f..b8694f39bb 100644
--- a/test/src/specs/relay/compact_block.rs
+++ b/test/src/specs/relay/compact_block.rs
@@ -8,7 +8,7 @@ use crate::utils::{
     build_header, build_headers, wait_until,
 };
 use crate::{Net, Node, Spec};
-use ckb_network::{bytes::Bytes, SupportProtocols};
+use ckb_network::{SupportProtocols, bytes::Bytes};
 use ckb_types::{
     core::{HeaderBuilder, HeaderView},
     h256,
@@ -668,7 +668,8 @@ impl Spec for CompactBlockRelayLessThenSharedBestKnown {
             build_compact_block(&new_block),
         );
         assert!(
-            wait_until(20, move || node0.get_tip_block().header().number() == old_tip + 1),
+            wait_until(20, move || node0.get_tip_block().header().number()
+                == old_tip + 1),
             "node0 should process the new block, even its difficulty is less than best_shared_known",
         );
     }
diff --git a/test/src/specs/relay/get_block_transactions_process.rs b/test/src/specs/relay/get_block_transactions_process.rs
index e621ad336d..f58c334bb0 100644
--- a/test/src/specs/relay/get_block_transactions_process.rs
+++ b/test/src/specs/relay/get_block_transactions_process.rs
@@ -1,6 +1,6 @@
 use crate::util::mining::out_ibd_mode;
 use crate::{Net, Node, Spec};
-use ckb_network::{bytes::Bytes, SupportProtocols};
+use ckb_network::{SupportProtocols, bytes::Bytes};
 use ckb_types::{
     core::UncleBlockView,
     packed::{self, RelayMessage},
diff --git a/test/src/specs/relay/transaction_relay.rs b/test/src/specs/relay/transaction_relay.rs
index 1a9512314c..6da0224925 100644
--- a/test/src/specs/relay/transaction_relay.rs
+++ b/test/src/specs/relay/transaction_relay.rs
@@ -9,7 +9,7 @@ use ckb_jsonrpc_types::Status;
 use ckb_logger::info;
 use ckb_network::SupportProtocols;
 use ckb_types::{
-    core::{capacity_bytes, Capacity, TransactionBuilder},
+    core::{Capacity, TransactionBuilder, capacity_bytes},
     packed::{CellOutputBuilder, GetRelayTransactions, RelayMessage},
     prelude::*,
 };
@@ -258,11 +258,12 @@ impl Spec for TransactionRelayConflict {
             .rpc_client()
             .send_transaction_result(tx2.data().into());
         assert!(res.is_err());
-        assert!(res
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("TransactionFailedToResolve: Resolve failed Dead"));
+        assert!(
+            res.err()
+                .unwrap()
+                .to_string()
+                .contains("TransactionFailedToResolve: Resolve failed Dead")
+        );
 
         let relayed = wait_until(20, || {
             [tx1.hash()].iter().all(|hash| {
diff --git a/test/src/specs/rpc/set_ban.rs b/test/src/specs/rpc/set_ban.rs
index e46b14645f..c8919f9753 100644
--- a/test/src/specs/rpc/set_ban.rs
+++ b/test/src/specs/rpc/set_ban.rs
@@ -57,20 +57,22 @@ impl Spec for RpcSetBan {
         let mut banned_ip_node = Node::new(spec_name(self), "banned_ip_node");
         banned_ip_node.modify_app_config(|app_config| {
             let p2p_port = find_available_port();
-            app_config.network.listen_addresses =
-                vec![format!("/ip4/{BAD_NODE_IP_1}/tcp/{p2p_port}")
+            app_config.network.listen_addresses = vec![
+                format!("/ip4/{BAD_NODE_IP_1}/tcp/{p2p_port}")
                     .parse()
-                    .unwrap()];
+                    .unwrap(),
+            ];
         });
         banned_ip_node.start();
 
         let mut banned_ipsubnet_node = Node::new(spec_name(self), "banned_ipsubnet_node");
         banned_ipsubnet_node.modify_app_config(|app_config| {
             let p2p_port = find_available_port();
-            app_config.network.listen_addresses =
-                vec![format!("/ip4/{BAD_NODE_IP_2}/tcp/{p2p_port}")
+            app_config.network.listen_addresses = vec![
+                format!("/ip4/{BAD_NODE_IP_2}/tcp/{p2p_port}")
                     .parse()
-                    .unwrap()];
+                    .unwrap(),
+            ];
         });
         banned_ipsubnet_node.start();
 
diff --git a/test/src/specs/rpc/transaction_proof.rs b/test/src/specs/rpc/transaction_proof.rs
index 0b5d83384e..2ef4aea532 100644
--- a/test/src/specs/rpc/transaction_proof.rs
+++ b/test/src/specs/rpc/transaction_proof.rs
@@ -1,4 +1,4 @@
-use crate::{Node, Spec, DEFAULT_TX_PROPOSAL_WINDOW};
+use crate::{DEFAULT_TX_PROPOSAL_WINDOW, Node, Spec};
 use ckb_types::prelude::*;
 
 pub struct RpcTransactionProof;
diff --git a/test/src/specs/sync/block_sync.rs b/test/src/specs/sync/block_sync.rs
index 10f2ef9ffe..83e29a831b 100644
--- a/test/src/specs/sync/block_sync.rs
+++ b/test/src/specs/sync/block_sync.rs
@@ -6,7 +6,7 @@ use crate::utils::{
 use crate::{Net, Node, Spec};
 use ckb_jsonrpc_types::ChainInfo;
 use ckb_logger::info;
-use ckb_network::{bytes::Bytes, extract_peer_id, SupportProtocols};
+use ckb_network::{SupportProtocols, bytes::Bytes, extract_peer_id};
 use ckb_types::{
     core::BlockView,
     packed::{self, Byte32, SendHeaders, SyncMessage},
diff --git a/test/src/specs/sync/chain_forks.rs b/test/src/specs/sync/chain_forks.rs
index b1d9132f6c..82249faf3b 100644
--- a/test/src/specs/sync/chain_forks.rs
+++ b/test/src/specs/sync/chain_forks.rs
@@ -8,7 +8,7 @@ use crate::util::transaction::always_success_transaction;
 use crate::{Node, Spec};
 use ckb_logger::info;
 use ckb_types::{
-    core::{capacity_bytes, BlockView, Capacity, TransactionView},
+    core::{BlockView, Capacity, TransactionView, capacity_bytes},
     h256,
     prelude::*,
 };
diff --git a/test/src/specs/tx_pool/cellbase_maturity.rs b/test/src/specs/tx_pool/cellbase_maturity.rs
index 69dc582ffa..13b2ee4f54 100644
--- a/test/src/specs/tx_pool/cellbase_maturity.rs
+++ b/test/src/specs/tx_pool/cellbase_maturity.rs
@@ -1,5 +1,5 @@
 use crate::utils::assert_send_transaction_fail;
-use crate::{Node, Spec, DEFAULT_TX_PROPOSAL_WINDOW};
+use crate::{DEFAULT_TX_PROPOSAL_WINDOW, Node, Spec};
 
 use ckb_logger::info;
 use ckb_types::core::BlockNumber;
diff --git a/test/src/specs/tx_pool/collision.rs b/test/src/specs/tx_pool/collision.rs
index 0d93697c03..82cdd88d6d 100644
--- a/test/src/specs/tx_pool/collision.rs
+++ b/test/src/specs/tx_pool/collision.rs
@@ -4,7 +4,7 @@ use crate::util::check::{
 use crate::utils::{assert_send_transaction_fail, blank, commit, propose};
 use crate::{Node, Spec};
 use ckb_types::bytes::Bytes;
-use ckb_types::core::{capacity_bytes, Capacity, TransactionView};
+use ckb_types::core::{Capacity, TransactionView, capacity_bytes};
 use ckb_types::prelude::*;
 
 // Convention:
@@ -27,11 +27,13 @@ impl Spec for TransactionHashCollisionDifferentWitnessHashes {
         node.submit_transaction(&tx1);
         let result = node.rpc_client().send_transaction_result(tx2.data().into());
 
-        assert!(result
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("PoolRejectedDuplicatedTransaction"));
+        assert!(
+            result
+                .err()
+                .unwrap()
+                .to_string()
+                .contains("PoolRejectedDuplicatedTransaction")
+        );
     }
 }
 
@@ -49,11 +51,13 @@ impl Spec for DuplicatedTransaction {
         node.submit_transaction(&tx1);
         let result = node.rpc_client().send_transaction_result(tx1.data().into());
 
-        assert!(result
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("PoolRejectedDuplicatedTransaction"));
+        assert!(
+            result
+                .err()
+                .unwrap()
+                .to_string()
+                .contains("PoolRejectedDuplicatedTransaction")
+        );
     }
 }
 
diff --git a/test/src/specs/tx_pool/different_txs_with_same_input.rs b/test/src/specs/tx_pool/different_txs_with_same_input.rs
index f590f7ae81..f0e74633fd 100644
--- a/test/src/specs/tx_pool/different_txs_with_same_input.rs
+++ b/test/src/specs/tx_pool/different_txs_with_same_input.rs
@@ -2,7 +2,7 @@ use crate::{Node, Spec};
 use ckb_jsonrpc_types::Status;
 use ckb_logger::info;
 use ckb_types::{
-    core::{capacity_bytes, Capacity, TransactionView},
+    core::{Capacity, TransactionView, capacity_bytes},
     packed::CellOutputBuilder,
     prelude::*,
 };
diff --git a/test/src/specs/tx_pool/get_raw_tx_pool.rs b/test/src/specs/tx_pool/get_raw_tx_pool.rs
index 1e3056f338..fcf4f53608 100644
--- a/test/src/specs/tx_pool/get_raw_tx_pool.rs
+++ b/test/src/specs/tx_pool/get_raw_tx_pool.rs
@@ -1,7 +1,7 @@
 use crate::{Node, Spec};
 use ckb_jsonrpc_types::RawTxPool;
 use ckb_logger::info;
-use ckb_types::{prelude::Unpack, H256};
+use ckb_types::{H256, prelude::Unpack};
 
 pub struct GetRawTxPool;
 
diff --git a/test/src/specs/tx_pool/limit.rs b/test/src/specs/tx_pool/limit.rs
index ba9a84df80..b587137f3b 100644
--- a/test/src/specs/tx_pool/limit.rs
+++ b/test/src/specs/tx_pool/limit.rs
@@ -1,11 +1,11 @@
 use crate::{
-    util::{cell::gen_spendable, transaction::always_success_transaction},
     Node, Spec,
+    util::{cell::gen_spendable, transaction::always_success_transaction},
 };
 use ckb_jsonrpc_types::Status;
 use ckb_logger::info;
 use ckb_types::{
-    core::{cell::CellMetaBuilder, DepType, FeeRate},
+    core::{DepType, FeeRate, cell::CellMetaBuilder},
     packed::CellDepBuilder,
 };
 use std::{thread::sleep, time::Duration};
diff --git a/test/src/specs/tx_pool/mod.rs b/test/src/specs/tx_pool/mod.rs
index 436fc44b93..bab0cc4022 100644
--- a/test/src/specs/tx_pool/mod.rs
+++ b/test/src/specs/tx_pool/mod.rs
@@ -52,10 +52,10 @@ pub use txs_relay_order::*;
 pub use valid_since::*;
 
 use ckb_app_config::BlockAssemblerConfig;
-use ckb_chain_spec::{build_genesis_type_id_script, OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL};
+use ckb_chain_spec::{OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL, build_genesis_type_id_script};
 use ckb_jsonrpc_types::JsonBytes;
 use ckb_resource::CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL;
-use ckb_types::{bytes::Bytes, core::ScriptHashType, prelude::*, H256};
+use ckb_types::{H256, bytes::Bytes, core::ScriptHashType, prelude::*};
 
 fn type_lock_script_code_hash() -> H256 {
     build_genesis_type_id_script(OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL)
diff --git a/test/src/specs/tx_pool/orphan_tx.rs b/test/src/specs/tx_pool/orphan_tx.rs
index 7e056380d5..424f3a11ea 100644
--- a/test/src/specs/tx_pool/orphan_tx.rs
+++ b/test/src/specs/tx_pool/orphan_tx.rs
@@ -6,7 +6,7 @@ use ckb_network::SupportProtocols;
 use ckb_types::packed::CellOutputBuilder;
 use ckb_types::{
     bytes::Bytes,
-    core::{capacity_bytes, Capacity, TransactionBuilder, TransactionView},
+    core::{Capacity, TransactionBuilder, TransactionView, capacity_bytes},
     packed,
 };
 use ckb_types::{
@@ -307,11 +307,12 @@ impl Spec for TxPoolOrphanUnordered {
         let ret = node0
             .rpc_client()
             .send_transaction_result(tx12_clone.data().into());
-        assert!(ret
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("already exists in transaction_pool"));
+        assert!(
+            ret.err()
+                .unwrap()
+                .to_string()
+                .contains("already exists in transaction_pool")
+        );
 
         assert!(
             run_replay_tx(&net, node0, parent, 3, 1),
diff --git a/test/src/specs/tx_pool/pool_reconcile.rs b/test/src/specs/tx_pool/pool_reconcile.rs
index 280c506cc8..7ede6a4e10 100644
--- a/test/src/specs/tx_pool/pool_reconcile.rs
+++ b/test/src/specs/tx_pool/pool_reconcile.rs
@@ -5,7 +5,7 @@ use crate::util::mining::out_ibd_mode;
 use crate::{Node, Spec};
 use ckb_jsonrpc_types::ProposalShortId;
 use ckb_logger::info;
-use ckb_types::core::{capacity_bytes, Capacity, FeeRate};
+use ckb_types::core::{Capacity, FeeRate, capacity_bytes};
 use ckb_types::packed::CellOutputBuilder;
 use ckb_types::{
     packed::{self, CellInput, OutPoint},
@@ -31,12 +31,14 @@ impl Spec for PoolReconcile {
         node0.mine_until_transaction_confirm(&hash);
 
         info!("Pool should be empty");
-        assert!(node0
-            .rpc_client()
-            .get_transaction(hash.clone())
-            .tx_status
-            .block_hash
-            .is_some());
+        assert!(
+            node0
+                .rpc_client()
+                .get_transaction(hash.clone())
+                .tx_status
+                .block_hash
+                .is_some()
+        );
 
         info!("Generate 5 blocks on node1");
         node1.mine(20);
@@ -47,12 +49,14 @@ impl Spec for PoolReconcile {
         waiting_for_sync(nodes);
 
         info!("Tx should be re-added to node0's pool");
-        assert!(node0
-            .rpc_client()
-            .get_transaction(hash)
-            .tx_status
-            .block_hash
-            .is_none());
+        assert!(
+            node0
+                .rpc_client()
+                .get_transaction(hash)
+                .tx_status
+                .block_hash
+                .is_none()
+        );
     }
 }
 
@@ -126,12 +130,14 @@ impl Spec for PoolResolveConflictAfterReorg {
         }
 
         info!("Tx1 mined by node1");
-        assert!(node0
-            .rpc_client()
-            .get_transaction(tx1.hash())
-            .tx_status
-            .block_hash
-            .is_some());
+        assert!(
+            node0
+                .rpc_client()
+                .get_transaction(tx1.hash())
+                .tx_status
+                .block_hash
+                .is_some()
+        );
 
         let tip_number0 = node0.get_tip_block_number();
         info!("Mine until node1 > node0");
@@ -160,9 +166,11 @@ impl Spec for PoolResolveConflictAfterReorg {
                     .previous_output(OutPoint::new(tx1.hash(), 0))
                     .build()
             }])
-            .set_outputs(vec![CellOutputBuilder::default()
-                .capacity(capacity_bytes!(99).pack())
-                .build()])
+            .set_outputs(vec![
+                CellOutputBuilder::default()
+                    .capacity(capacity_bytes!(99).pack())
+                    .build(),
+            ])
             .build();
 
         let ret = node0
diff --git a/test/src/specs/tx_pool/pool_resurrect.rs b/test/src/specs/tx_pool/pool_resurrect.rs
index 9160e7edd0..994f8e567a 100644
--- a/test/src/specs/tx_pool/pool_resurrect.rs
+++ b/test/src/specs/tx_pool/pool_resurrect.rs
@@ -1,5 +1,5 @@
 use crate::node::waiting_for_sync;
-use crate::{Node, Spec, DEFAULT_TX_PROPOSAL_WINDOW};
+use crate::{DEFAULT_TX_PROPOSAL_WINDOW, Node, Spec};
 use ckb_logger::info;
 
 pub struct PoolResurrect;
diff --git a/test/src/specs/tx_pool/remove_tx.rs b/test/src/specs/tx_pool/remove_tx.rs
index 227771b260..30351c4de4 100644
--- a/test/src/specs/tx_pool/remove_tx.rs
+++ b/test/src/specs/tx_pool/remove_tx.rs
@@ -1,9 +1,9 @@
 use ckb_network::SupportProtocols;
 
 use crate::{
+    Net, Node, Spec,
     util::{check, transaction::relay_tx},
     utils::wait_until,
-    Net, Node, Spec,
 };
 
 const ALWAYS_SUCCESS_SCRIPT_CYCLE: u64 = 537;
diff --git a/test/src/specs/tx_pool/replace.rs b/test/src/specs/tx_pool/replace.rs
index b6ef175906..0455d8155b 100644
--- a/test/src/specs/tx_pool/replace.rs
+++ b/test/src/specs/tx_pool/replace.rs
@@ -1,4 +1,5 @@
 use crate::{
+    Node, Spec,
     rpc::RpcClient,
     util::{
         cell::gen_spendable,
@@ -7,12 +8,11 @@ use crate::{
         },
     },
     utils::wait_until,
-    Node, Spec,
 };
 use ckb_jsonrpc_types::Status;
 use ckb_logger::info;
 use ckb_types::{
-    core::{capacity_bytes, cell::CellMetaBuilder, Capacity, DepType, TransactionView},
+    core::{Capacity, DepType, TransactionView, capacity_bytes, cell::CellMetaBuilder},
     packed::{Byte32, CellDep, CellDepBuilder, CellInput, CellOutputBuilder, OutPoint},
     prelude::*,
 };
@@ -312,11 +312,12 @@ impl Spec for RbfTooManyDescendants {
             .rpc_client()
             .send_transaction_result(tx2.data().into());
         assert!(res.is_err(), "tx2 should be rejected");
-        assert!(res
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("Tx conflict with too many txs"));
+        assert!(
+            res.err()
+                .unwrap()
+                .to_string()
+                .contains("Tx conflict with too many txs")
+        );
 
         // local submit tx RBF check failed, will not in conflicts pool
         assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().unpack()]);
@@ -387,11 +388,12 @@ impl Spec for RbfContainNewTx {
             .rpc_client()
             .send_transaction_result(tx2.data().into());
         assert!(res.is_err(), "tx2 should be rejected");
-        assert!(res
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("new Tx contains unconfirmed inputs"));
+        assert!(
+            res.err()
+                .unwrap()
+                .to_string()
+                .contains("new Tx contains unconfirmed inputs")
+        );
 
         // local submit tx RBF check failed, will be in conflicts pool
         assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().unpack()]);
@@ -462,11 +464,12 @@ impl Spec for RbfContainInvalidInput {
             .rpc_client()
             .send_transaction_result(tx2.data().into());
         assert!(res.is_err(), "tx2 should be rejected");
-        assert!(res
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("new Tx contains inputs in descendants of to be replaced Tx"));
+        assert!(
+            res.err()
+                .unwrap()
+                .to_string()
+                .contains("new Tx contains inputs in descendants of to be replaced Tx")
+        );
 
         // local submit tx RBF check failed, will not in conflicts pool
         assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().unpack()]);
@@ -733,11 +736,12 @@ impl Spec for RbfRejectReplaceProposed {
         assert!(res.is_err(), "tx2 should be rejected");
 
         // resolve tx2 failed with `unknown` when resolve inputs used by tx1
-        assert!(res
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("TransactionFailedToResolve: Resolve failed Unknown"));
+        assert!(
+            res.err()
+                .unwrap()
+                .to_string()
+                .contains("TransactionFailedToResolve: Resolve failed Unknown")
+        );
     }
 
     fn modify_app_config(&self, config: &mut ckb_app_config::CKBAppConfig) {
@@ -1000,11 +1004,12 @@ impl Spec for RbfCellDepsCheck {
             .build();
 
         let res = node0.submit_transaction_with_result(&new_tx);
-        assert!(res
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("new Tx contains cell deps from conflicts"));
+        assert!(
+            res.err()
+                .unwrap()
+                .to_string()
+                .contains("new Tx contains cell deps from conflicts")
+        );
         assert_eq!(get_tx_pool_conflicts(node0), vec![new_tx.hash().unpack()]);
     }
 
diff --git a/test/src/specs/tx_pool/send_defected_binary.rs b/test/src/specs/tx_pool/send_defected_binary.rs
index 76dab8dbe3..b9af1d9a46 100644
--- a/test/src/specs/tx_pool/send_defected_binary.rs
+++ b/test/src/specs/tx_pool/send_defected_binary.rs
@@ -5,11 +5,11 @@ use ckb_crypto::secp::{Generator, Privkey};
 use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_logger::info;
 use ckb_types::{
+    H256,
     bytes::Bytes,
-    core::{capacity_bytes, Capacity, DepType, ScriptHashType, TransactionBuilder},
+    core::{Capacity, DepType, ScriptHashType, TransactionBuilder, capacity_bytes},
     packed::{CellDep, CellInput, CellOutput, OutPoint, WitnessArgs},
     prelude::*,
-    H256,
 };
 
 pub struct SendDefectedBinary {
diff --git a/test/src/specs/tx_pool/send_large_cycles_tx.rs b/test/src/specs/tx_pool/send_large_cycles_tx.rs
index ce4d4ec09e..20c7c674eb 100644
--- a/test/src/specs/tx_pool/send_large_cycles_tx.rs
+++ b/test/src/specs/tx_pool/send_large_cycles_tx.rs
@@ -8,14 +8,14 @@ use ckb_jsonrpc_types::Status;
 use ckb_logger::info;
 use ckb_network::SupportProtocols;
 use ckb_types::{
+    H256,
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockView, Capacity, DepType, ScriptHashType, TransactionBuilder,
-        TransactionView,
+        BlockView, Capacity, DepType, ScriptHashType, TransactionBuilder, TransactionView,
+        capacity_bytes,
     },
     packed::{CellDep, CellInput, CellOutput, OutPoint, Script, WitnessArgs},
     prelude::*,
-    H256,
 };
 
 pub struct SendLargeCyclesTxInBlock {
diff --git a/test/src/specs/tx_pool/send_multisig_secp_tx.rs b/test/src/specs/tx_pool/send_multisig_secp_tx.rs
index f0de38db6f..bec4931f27 100644
--- a/test/src/specs/tx_pool/send_multisig_secp_tx.rs
+++ b/test/src/specs/tx_pool/send_multisig_secp_tx.rs
@@ -1,18 +1,18 @@
 use crate::util::check::is_transaction_committed;
 use crate::{Node, Spec};
 use ckb_app_config::BlockAssemblerConfig;
-use ckb_chain_spec::{build_genesis_type_id_script, OUTPUT_INDEX_SECP256K1_BLAKE160_MULTISIG_ALL};
+use ckb_chain_spec::{OUTPUT_INDEX_SECP256K1_BLAKE160_MULTISIG_ALL, build_genesis_type_id_script};
 use ckb_crypto::secp::{Generator, Privkey};
 use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_jsonrpc_types::JsonBytes;
 use ckb_logger::info;
 use ckb_resource::CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL;
 use ckb_types::{
+    H160, H256,
     bytes::Bytes,
-    core::{capacity_bytes, Capacity, DepType, ScriptHashType, TransactionBuilder},
+    core::{Capacity, DepType, ScriptHashType, TransactionBuilder, capacity_bytes},
     packed::{CellDep, CellInput, CellOutput, OutPoint, WitnessArgs},
     prelude::*,
-    H160, H256,
 };
 
 pub struct SendMultiSigSecpTxUseDepGroup {
diff --git a/test/src/specs/tx_pool/send_secp_tx.rs b/test/src/specs/tx_pool/send_secp_tx.rs
index 7449c7454c..111bc1d2ec 100644
--- a/test/src/specs/tx_pool/send_secp_tx.rs
+++ b/test/src/specs/tx_pool/send_secp_tx.rs
@@ -5,11 +5,11 @@ use ckb_crypto::secp::{Generator, Privkey};
 use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_logger::info;
 use ckb_types::{
+    H256,
     bytes::Bytes,
-    core::{capacity_bytes, Capacity, DepType, ScriptHashType, TransactionBuilder},
+    core::{Capacity, DepType, ScriptHashType, TransactionBuilder, capacity_bytes},
     packed::{CellDep, CellInput, CellOutput, OutPoint, Script, WitnessArgs},
     prelude::*,
-    H256,
 };
 
 pub struct SendSecpTxUseDepGroup {
diff --git a/test/src/specs/tx_pool/send_tx_chain.rs b/test/src/specs/tx_pool/send_tx_chain.rs
index 99164f664b..1ed0bd84fb 100644
--- a/test/src/specs/tx_pool/send_tx_chain.rs
+++ b/test/src/specs/tx_pool/send_tx_chain.rs
@@ -102,11 +102,12 @@ impl Spec for SendTxChain {
             .rpc_client()
             .send_transaction_result(txs.last().unwrap().data().into());
         assert!(ret.is_err());
-        assert!(ret
-            .err()
-            .unwrap()
-            .to_string()
-            .contains("Transaction exceeded maximum ancestors count limit"));
+        assert!(
+            ret.err()
+                .unwrap()
+                .to_string()
+                .contains("Transaction exceeded maximum ancestors count limit")
+        );
     }
 
     fn modify_app_config(&self, config: &mut ckb_app_config::CKBAppConfig) {
diff --git a/test/src/specs/tx_pool/valid_since.rs b/test/src/specs/tx_pool/valid_since.rs
index ee16dac4a4..b69edc18b1 100644
--- a/test/src/specs/tx_pool/valid_since.rs
+++ b/test/src/specs/tx_pool/valid_since.rs
@@ -3,7 +3,7 @@ use crate::utils::{
     assert_send_transaction_fail, since_from_absolute_block_number, since_from_absolute_timestamp,
     since_from_relative_block_number, since_from_relative_timestamp,
 };
-use crate::{Node, Spec, DEFAULT_TX_PROPOSAL_WINDOW};
+use crate::{DEFAULT_TX_PROPOSAL_WINDOW, Node, Spec};
 
 use ckb_logger::info;
 use ckb_types::core::{BlockNumber, TransactionView};
diff --git a/test/src/txo.rs b/test/src/txo.rs
index 7d9868b6f4..9d9b5e636a 100644
--- a/test/src/txo.rs
+++ b/test/src/txo.rs
@@ -1,7 +1,7 @@
 use ckb_types::core::{Capacity, TransactionBuilder, TransactionView};
 use ckb_types::packed::{CellDep, CellInput, CellOutput, OutPoint, Script, ScriptOpt};
 use ckb_types::prelude::*;
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 use std::collections::HashMap;
 
 const EXPLODE_LIMIT: usize = 2000;
diff --git a/test/src/util/log_monitor.rs b/test/src/util/log_monitor.rs
index 1c0c5d5b3f..3a88128045 100644
--- a/test/src/util/log_monitor.rs
+++ b/test/src/util/log_monitor.rs
@@ -1,6 +1,6 @@
 use crate::node::Node;
 use crate::utils::{sleep, tweaked_duration};
-use std::fs::{metadata, File};
+use std::fs::{File, metadata};
 use std::io::{BufRead, BufReader, Seek, SeekFrom};
 use std::time::Instant;
 
diff --git a/test/src/util/mining.rs b/test/src/util/mining.rs
index ebbf686522..7f89004e88 100644
--- a/test/src/util/mining.rs
+++ b/test/src/util/mining.rs
@@ -1,6 +1,6 @@
-use crate::util::chain::forward_main_blocks;
-use crate::Node;
 use crate::DEFAULT_TX_PROPOSAL_WINDOW;
+use crate::Node;
+use crate::util::chain::forward_main_blocks;
 use ckb_jsonrpc_types::{BlockTemplate, ProposalShortId};
 use ckb_types::{
     core::{BlockBuilder, BlockView, EpochNumberWithFraction, HeaderView},
diff --git a/test/src/util/transaction.rs b/test/src/util/transaction.rs
index 35e640cd64..c3062f62c4 100644
--- a/test/src/util/transaction.rs
+++ b/test/src/util/transaction.rs
@@ -4,7 +4,7 @@ use ckb_jsonrpc_types::{RawTxPool, TxPoolEntries};
 use ckb_network::SupportProtocols;
 use ckb_types::{
     bytes::Bytes,
-    core::{cell::CellMeta, TransactionBuilder, TransactionView},
+    core::{TransactionBuilder, TransactionView, cell::CellMeta},
     packed,
     prelude::*,
 };
diff --git a/test/src/worker.rs b/test/src/worker.rs
index 88ae61624f..087d797b66 100644
--- a/test/src/worker.rs
+++ b/test/src/worker.rs
@@ -1,11 +1,11 @@
-use crate::{utils::nodes_panicked, Spec};
-use ckb_channel::{unbounded, Receiver, Sender};
+use crate::{Spec, utils::nodes_panicked};
+use ckb_channel::{Receiver, Sender, unbounded};
 use ckb_logger::{error, info};
 use ckb_util::Mutex;
 use std::any::Any;
 use std::panic;
 use std::path::PathBuf;
-use std::sync::{atomic::AtomicU16, Arc};
+use std::sync::{Arc, atomic::AtomicU16};
 use std::thread::{self, JoinHandle};
 use std::time::Instant;
 
diff --git a/tx-pool/src/block_assembler/candidate_uncles.rs b/tx-pool/src/block_assembler/candidate_uncles.rs
index c4ee239152..6bd0500302 100644
--- a/tx-pool/src/block_assembler/candidate_uncles.rs
+++ b/tx-pool/src/block_assembler/candidate_uncles.rs
@@ -1,5 +1,5 @@
 use ckb_types::core::{BlockNumber, EpochExt, UncleBlockView};
-use std::collections::{btree_map::Entry, BTreeMap, HashSet};
+use std::collections::{BTreeMap, HashSet, btree_map::Entry};
 
 use ckb_snapshot::Snapshot;
 use ckb_store::ChainStore;
diff --git a/tx-pool/src/block_assembler/mod.rs b/tx-pool/src/block_assembler/mod.rs
index dc6e0a1e93..b14cbcf7b6 100644
--- a/tx-pool/src/block_assembler/mod.rs
+++ b/tx-pool/src/block_assembler/mod.rs
@@ -23,9 +23,9 @@ use ckb_systemtime::unix_time_as_millis;
 use ckb_types::{
     bytes,
     core::{
-        cell::{OverlayCellChecker, TransactionsChecker},
         BlockNumber, Capacity, Cycle, EpochExt, EpochNumberWithFraction, ScriptHashType,
         TransactionBuilder, TransactionView, UncleBlockView, Version,
+        cell::{OverlayCellChecker, TransactionsChecker},
     },
     packed::{
         self, Byte32, Bytes, CellInput, CellOutput, CellbaseWitness, ProposalShortId, Script,
@@ -35,11 +35,11 @@ use ckb_types::{
 };
 use http_body_util::Full;
 use hyper::{Method, Request};
-use hyper_util::client::legacy::{connect::HttpConnector, Client};
+use hyper_util::client::legacy::{Client, connect::HttpConnector};
 use std::collections::HashSet;
 use std::sync::{
-    atomic::{AtomicU64, Ordering},
     Arc,
+    atomic::{AtomicU64, Ordering},
 };
 use std::time::Duration;
 use std::{cmp, iter};
diff --git a/tx-pool/src/component/edges.rs b/tx-pool/src/component/edges.rs
index 76f33055b4..7169053e6c 100644
--- a/tx-pool/src/component/edges.rs
+++ b/tx-pool/src/component/edges.rs
@@ -2,7 +2,7 @@ use ckb_types::{
     core::tx_pool::Reject,
     packed::{Byte32, OutPoint, ProposalShortId},
 };
-use std::collections::{hash_map::Entry, HashMap, HashSet};
+use std::collections::{HashMap, HashSet, hash_map::Entry};
 
 #[derive(Default, Debug, Clone)]
 pub(crate) struct Edges {
@@ -38,10 +38,11 @@ impl Edges {
         // inputs is occupied means double speanding happened here
         match self.inputs.entry(out_point.clone()) {
             Entry::Occupied(occupied) => {
-                let msg =
-                    format!(
+                let msg = format!(
                     "txpool unexpected double-spending out_point: {:?} old_tx: {:?} new_tx: {:?}",
-                    out_point, occupied.get(), txid
+                    out_point,
+                    occupied.get(),
+                    txid
                 );
                 Err(Reject::RBFRejected(msg))
             }
diff --git a/tx-pool/src/component/entry.rs b/tx-pool/src/component/entry.rs
index f45d4feace..29a29ad181 100644
--- a/tx-pool/src/component/entry.rs
+++ b/tx-pool/src/component/entry.rs
@@ -2,9 +2,9 @@ use crate::component::sort_key::{AncestorsScoreSortKey, EvictKey};
 use ckb_systemtime::unix_time_as_millis;
 use ckb_types::{
     core::{
-        cell::ResolvedTransaction,
-        tx_pool::{get_transaction_weight, TxEntryInfo},
         Capacity, Cycle, FeeRate, TransactionView,
+        cell::ResolvedTransaction,
+        tx_pool::{TxEntryInfo, get_transaction_weight},
     },
     packed::{OutPoint, ProposalShortId},
 };
diff --git a/tx-pool/src/component/pool_map.rs b/tx-pool/src/component/pool_map.rs
index dc54a89bc3..dcf344f3b1 100644
--- a/tx-pool/src/component/pool_map.rs
+++ b/tx-pool/src/component/pool_map.rs
@@ -2,11 +2,11 @@
 extern crate rustc_hash;
 extern crate slab;
 use super::links::TxLinks;
+use crate::TxEntry;
 use crate::component::edges::Edges;
 use crate::component::links::{Relation, TxLinksMap};
 use crate::component::sort_key::{AncestorsScoreSortKey, EvictKey};
 use crate::error::Reject;
-use crate::TxEntry;
 use ckb_logger::{debug, error, trace};
 use ckb_types::core::error::OutPointError;
 use ckb_types::core::{Cycle, FeeRate};
diff --git a/tx-pool/src/component/recent_reject.rs b/tx-pool/src/component/recent_reject.rs
index 2f8a11d7ee..2428651b18 100644
--- a/tx-pool/src/component/recent_reject.rs
+++ b/tx-pool/src/component/recent_reject.rs
@@ -3,7 +3,7 @@ use ckb_db::DBWithTTL;
 use ckb_error::AnyError;
 use ckb_types::{packed::Byte32, prelude::*};
 use rand::distributions::Uniform;
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 use std::path::Path;
 
 const DEFAULT_SHARDS: u32 = 5;
diff --git a/tx-pool/src/component/sort_key.rs b/tx-pool/src/component/sort_key.rs
index 4921b8571a..40701fc5fd 100644
--- a/tx-pool/src/component/sort_key.rs
+++ b/tx-pool/src/component/sort_key.rs
@@ -1,5 +1,5 @@
 use ckb_types::core::{
-    tx_pool::AncestorsScoreSortKey as CoreAncestorsScoreSortKey, Capacity, FeeRate,
+    Capacity, FeeRate, tx_pool::AncestorsScoreSortKey as CoreAncestorsScoreSortKey,
 };
 use std::cmp::Ordering;
 
diff --git a/tx-pool/src/component/tests/chunk.rs b/tx-pool/src/component/tests/chunk.rs
index 39df2dc1cd..33e8545bc4 100644
--- a/tx-pool/src/component/tests/chunk.rs
+++ b/tx-pool/src/component/tests/chunk.rs
@@ -1,9 +1,9 @@
 use crate::component::tests::util::build_tx;
 use crate::component::verify_queue::{Entry, VerifyQueue};
 use ckb_network::SessionId;
+use ckb_types::H256;
 use ckb_types::core::TransactionBuilder;
 use ckb_types::prelude::Pack;
-use ckb_types::H256;
 use tokio::select;
 use tokio::sync::watch;
 use tokio::time::sleep;
@@ -100,9 +100,11 @@ async fn test_verify_different_cycles() {
     sleep(std::time::Duration::from_millis(100)).await;
 
     let tx1 = build_tx(vec![(&H256([1; 32]).pack(), 0)], 1);
-    assert!(queue
-        .add_tx(tx1.clone(), remote(MAX_TX_VERIFY_CYCLES + 1))
-        .unwrap());
+    assert!(
+        queue
+            .add_tx(tx1.clone(), remote(MAX_TX_VERIFY_CYCLES + 1))
+            .unwrap()
+    );
     sleep(std::time::Duration::from_millis(100)).await;
 
     let tx2 = build_tx(vec![(&H256([2; 32]).pack(), 0)], 1);
diff --git a/tx-pool/src/component/tests/pending.rs b/tx-pool/src/component/tests/pending.rs
index e262248354..e1c97e318e 100644
--- a/tx-pool/src/component/tests/pending.rs
+++ b/tx-pool/src/component/tests/pending.rs
@@ -1,6 +1,6 @@
 use crate::component::edges::Edges;
 use crate::component::tests::util::{
-    build_tx, build_tx_with_dep, build_tx_with_header_dep, MOCK_CYCLES, MOCK_FEE, MOCK_SIZE,
+    MOCK_CYCLES, MOCK_FEE, MOCK_SIZE, build_tx, build_tx_with_dep, build_tx_with_header_dep,
 };
 use crate::component::{
     entry::TxEntry,
diff --git a/tx-pool/src/component/tests/proposed.rs b/tx-pool/src/component/tests/proposed.rs
index 236d4b10a9..482461254c 100644
--- a/tx-pool/src/component/tests/proposed.rs
+++ b/tx-pool/src/component/tests/proposed.rs
@@ -1,19 +1,19 @@
 use crate::component::pool_map::Status;
 use crate::component::tests::util::{
-    build_tx, build_tx_with_dep, build_tx_with_header_dep, DEFAULT_MAX_ANCESTORS_COUNT,
-    MOCK_CYCLES, MOCK_FEE, MOCK_SIZE,
+    DEFAULT_MAX_ANCESTORS_COUNT, MOCK_CYCLES, MOCK_FEE, MOCK_SIZE, build_tx, build_tx_with_dep,
+    build_tx_with_header_dep,
 };
-use ckb_types::core::{capacity_bytes, ScriptHashType};
-use ckb_types::packed::{CellOutputBuilder, ScriptBuilder};
 use ckb_types::H256;
+use ckb_types::core::{ScriptHashType, capacity_bytes};
+use ckb_types::packed::{CellOutputBuilder, ScriptBuilder};
 use std::time::Instant;
 
 use crate::component::{entry::TxEntry, pool_map::PoolMap};
 use ckb_types::{
     bytes::Bytes,
     core::{
-        cell::{get_related_dep_out_points, CellMeta, ResolvedTransaction},
         Capacity, DepType, TransactionBuilder, TransactionView,
+        cell::{CellMeta, ResolvedTransaction, get_related_dep_out_points},
     },
     h256,
     packed::{Byte32, CellDep, CellInput, CellOutput, OutPoint},
@@ -152,11 +152,12 @@ fn test_add_entry_from_detached() {
         .collect::<Vec<_>>();
     assert_eq!(left, got);
 
-    assert!(pool
-        .links
-        .get_parents(&entry2.proposal_short_id())
-        .unwrap()
-        .is_empty());
+    assert!(
+        pool.links
+            .get_parents(&entry2.proposal_short_id())
+            .unwrap()
+            .is_empty()
+    );
 
     assert!(pool.add_proposed(entry1).unwrap());
 
@@ -684,10 +685,11 @@ fn test_max_ancestors_with_dep() {
     assert!(pool.add_proposed(entry1).is_ok());
     assert!(pool.add_proposed(entry2).is_err());
     assert_eq!(pool.edges.deps.len(), 1);
-    assert!(pool
-        .edges
-        .deps
-        .contains_key(&OutPoint::new(h256!("0x1").pack(), 0)));
+    assert!(
+        pool.edges
+            .deps
+            .contains_key(&OutPoint::new(h256!("0x1").pack(), 0))
+    );
     assert!(pool.calc_descendants(&tx1_id).is_empty());
 
     assert_eq!(pool.edges.inputs_len(), 1);
diff --git a/tx-pool/src/component/verify_queue.rs b/tx-pool/src/component/verify_queue.rs
index d770c19025..98097fac9b 100644
--- a/tx-pool/src/component/verify_queue.rs
+++ b/tx-pool/src/component/verify_queue.rs
@@ -6,7 +6,7 @@ use ckb_logger::error;
 use ckb_network::PeerIndex;
 use ckb_systemtime::unix_time_as_millis;
 use ckb_types::{
-    core::{tx_pool::Reject, Cycle, TransactionView},
+    core::{Cycle, TransactionView, tx_pool::Reject},
     packed::ProposalShortId,
 };
 use ckb_util::shrink_to_fit;
diff --git a/tx-pool/src/error.rs b/tx-pool/src/error.rs
index 6804051908..2c345dcfed 100644
--- a/tx-pool/src/error.rs
+++ b/tx-pool/src/error.rs
@@ -2,8 +2,8 @@
 
 use ckb_channel::oneshot::RecvError;
 use ckb_error::{
-    impl_error_conversion_with_adaptor, impl_error_conversion_with_kind, prelude::*, Error,
-    InternalError, InternalErrorKind, OtherError,
+    Error, InternalError, InternalErrorKind, OtherError, impl_error_conversion_with_adaptor,
+    impl_error_conversion_with_kind, prelude::*,
 };
 pub use ckb_types::core::tx_pool::Reject;
 use std::fmt;
diff --git a/tx-pool/src/pool.rs b/tx-pool/src/pool.rs
index 66cbf0d424..5a7ff07551 100644
--- a/tx-pool/src/pool.rs
+++ b/tx-pool/src/pool.rs
@@ -1,7 +1,7 @@
 //! Top-level Pool type, methods, and tests
 extern crate rustc_hash;
 extern crate slab;
-use super::component::{commit_txs_scanner::CommitTxsScanner, TxEntry};
+use super::component::{TxEntry, commit_txs_scanner::CommitTxsScanner};
 use crate::callback::Callbacks;
 use crate::component::pool_map::{PoolEntry, PoolMap, Status};
 use crate::component::recent_reject::RecentReject;
@@ -17,9 +17,9 @@ use ckb_types::core::{BlockNumber, CapacityError, FeeRate};
 use ckb_types::packed::OutPoint;
 use ckb_types::{
     core::{
-        cell::{resolve_transaction, OverlayCellChecker, OverlayCellProvider, ResolvedTransaction},
-        tx_pool::{TxPoolEntryInfo, TxPoolIds},
         Capacity, Cycle, TransactionView, UncleBlockView,
+        cell::{OverlayCellChecker, OverlayCellProvider, ResolvedTransaction, resolve_transaction},
+        tx_pool::{TxPoolEntryInfo, TxPoolIds},
     },
     packed::{Byte32, ProposalShortId},
 };
diff --git a/tx-pool/src/process.rs b/tx-pool/src/process.rs
index 8d38017ac1..7d0652b92a 100644
--- a/tx-pool/src/process.rs
+++ b/tx-pool/src/process.rs
@@ -22,15 +22,15 @@ use ckb_snapshot::Snapshot;
 use ckb_types::core::error::OutPointError;
 use ckb_types::{
     core::{
-        cell::ResolvedTransaction, BlockView, Capacity, Cycle, EstimateMode, FeeRate, HeaderView,
-        TransactionView,
+        BlockView, Capacity, Cycle, EstimateMode, FeeRate, HeaderView, TransactionView,
+        cell::ResolvedTransaction,
     },
     packed::{Byte32, ProposalShortId},
 };
 use ckb_util::LinkedHashSet;
 use ckb_verification::{
-    cache::{CacheEntry, Completed},
     TxVerifyEnv,
+    cache::{CacheEntry, Completed},
 };
 use std::collections::HashSet;
 use std::collections::{HashMap, VecDeque};
@@ -673,7 +673,7 @@ impl TxPoolService {
         const DEFAULT_BAN_TIME: Duration = Duration::from_secs(3600 * 24 * 3);
 
         #[cfg(feature = "with_sentry")]
-        use sentry::{capture_message, with_scope, Level};
+        use sentry::{Level, capture_message, with_scope};
 
         #[cfg(feature = "with_sentry")]
         with_scope(
diff --git a/tx-pool/src/service.rs b/tx-pool/src/service.rs
index 7ed781254e..9eac727edc 100644
--- a/tx-pool/src/service.rs
+++ b/tx-pool/src/service.rs
@@ -25,12 +25,12 @@ use ckb_stop_handler::new_tokio_exit_rx;
 use ckb_store::ChainStore;
 use ckb_types::{
     core::{
+        BlockView, Cycle, EstimateMode, FeeRate, TransactionView, UncleBlockView, Version,
         cell::{CellProvider, CellStatus, OverlayCellProvider},
         tx_pool::{
-            EntryCompleted, PoolTxDetailInfo, Reject, TransactionWithStatus, TxPoolEntryInfo,
-            TxPoolIds, TxPoolInfo, TxStatus, TRANSACTION_SIZE_LIMIT,
+            EntryCompleted, PoolTxDetailInfo, Reject, TRANSACTION_SIZE_LIMIT,
+            TransactionWithStatus, TxPoolEntryInfo, TxPoolIds, TxPoolInfo, TxStatus,
         },
-        BlockView, Cycle, EstimateMode, FeeRate, TransactionView, UncleBlockView, Version,
     },
     packed::{Byte32, OutPoint, ProposalShortId},
 };
@@ -38,12 +38,12 @@ use ckb_util::{LinkedHashMap, LinkedHashSet};
 use ckb_verification::cache::TxVerificationCache;
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::sync::{
-    atomic::{AtomicBool, Ordering},
     Arc,
+    atomic::{AtomicBool, Ordering},
 };
 use std::time::Duration;
 use tokio::sync::watch;
-use tokio::sync::{mpsc, RwLock};
+use tokio::sync::{RwLock, mpsc};
 use tokio::task::block_in_place;
 use tokio_util::sync::CancellationToken;
 
diff --git a/tx-pool/src/util.rs b/tx-pool/src/util.rs
index 88cd229fa3..57c89c0caa 100644
--- a/tx-pool/src/util.rs
+++ b/tx-pool/src/util.rs
@@ -4,16 +4,16 @@ use ckb_chain_spec::consensus::Consensus;
 use ckb_dao::DaoCalculator;
 use ckb_script::ChunkCommand;
 use ckb_snapshot::Snapshot;
-use ckb_store::data_loader_wrapper::AsDataLoader;
 use ckb_store::ChainStore;
+use ckb_store::data_loader_wrapper::AsDataLoader;
 use ckb_types::core::{
-    cell::ResolvedTransaction, tx_pool::TRANSACTION_SIZE_LIMIT, Capacity, Cycle, EpochNumber,
-    TransactionView,
+    Capacity, Cycle, EpochNumber, TransactionView, cell::ResolvedTransaction,
+    tx_pool::TRANSACTION_SIZE_LIMIT,
 };
 use ckb_verification::{
-    cache::{CacheEntry, Completed},
     ContextualTransactionVerifier, DaoScriptSizeVerifier, NonContextualTransactionVerifier,
     TimeRelativeTransactionVerifier, TxVerifyEnv,
+    cache::{CacheEntry, Completed},
 };
 use std::sync::Arc;
 use tokio::{sync::watch, task::block_in_place};
diff --git a/tx-pool/src/verify_mgr.rs b/tx-pool/src/verify_mgr.rs
index 0734ee8ab5..8493a1bfe1 100644
--- a/tx-pool/src/verify_mgr.rs
+++ b/tx-pool/src/verify_mgr.rs
@@ -5,7 +5,7 @@ use ckb_logger::{debug, info};
 use ckb_script::ChunkCommand;
 use ckb_stop_handler::CancellationToken;
 use std::sync::Arc;
-use tokio::sync::{watch, RwLock};
+use tokio::sync::{RwLock, watch};
 use tokio::task::JoinHandle;
 
 #[derive(Clone, Debug, PartialEq)]
@@ -98,8 +98,8 @@ impl Worker {
                             tasks.re_notify();
                             debug!(
                                 "Worker (role: {:?}) didn't got tx after pop_front, but tasks is not empty, notify other Workers now",
-                            self.role
-                        );
+                                self.role
+                            );
                         }
                         return;
                     }
diff --git a/util/app-config/src/app_config.rs b/util/app-config/src/app_config.rs
index d10819c876..bbc283852c 100644
--- a/util/app-config/src/app_config.rs
+++ b/util/app-config/src/app_config.rs
@@ -19,7 +19,7 @@ use ckb_resource::Resource;
 use super::configs::*;
 #[cfg(feature = "with_sentry")]
 use super::sentry_config::SentryConfig;
-use super::{cli, legacy, ExitCode};
+use super::{ExitCode, cli, legacy};
 
 /// The parsed config file.
 ///
diff --git a/util/app-config/src/configs/mod.rs b/util/app-config/src/configs/mod.rs
index 2dcfd82412..4b0d617176 100644
--- a/util/app-config/src/configs/mod.rs
+++ b/util/app-config/src/configs/mod.rs
@@ -20,8 +20,8 @@ pub use miner::{
     ExtraHashFunction, WorkerConfig as MinerWorkerConfig,
 };
 pub use network::{
-    default_support_all_protocols, Config as NetworkConfig, HeaderMapConfig, SupportProtocol,
-    SyncConfig,
+    Config as NetworkConfig, HeaderMapConfig, SupportProtocol, SyncConfig,
+    default_support_all_protocols,
 };
 pub use network_alert::Config as NetworkAlertConfig;
 pub use notify::Config as NotifyConfig;
diff --git a/util/app-config/src/configs/tx_pool.rs b/util/app-config/src/configs/tx_pool.rs
index a24c7938de..5175ac09b1 100644
--- a/util/app-config/src/configs/tx_pool.rs
+++ b/util/app-config/src/configs/tx_pool.rs
@@ -1,6 +1,6 @@
 use ckb_jsonrpc_types::{FeeRateDef, JsonBytes, ScriptHashType};
-use ckb_types::core::{Cycle, FeeRate};
 use ckb_types::H256;
+use ckb_types::core::{Cycle, FeeRate};
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
 use url::Url;
diff --git a/util/app-config/src/sentry_config.rs b/util/app-config/src/sentry_config.rs
index b7a1f29f7e..68816d4101 100644
--- a/util/app-config/src/sentry_config.rs
+++ b/util/app-config/src/sentry_config.rs
@@ -2,7 +2,7 @@
 
 use ckb_build_info::Version;
 use sentry::{
-    configure_scope, init, protocol::Event, types::Dsn, ClientInitGuard, ClientOptions, Level,
+    ClientInitGuard, ClientOptions, Level, configure_scope, init, protocol::Event, types::Dsn,
 };
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
diff --git a/util/app-config/src/tests/legacy.rs b/util/app-config/src/tests/legacy.rs
index cc840c4b67..d47fa0b8d4 100644
--- a/util/app-config/src/tests/legacy.rs
+++ b/util/app-config/src/tests/legacy.rs
@@ -1,4 +1,4 @@
-use ckb_resource::{Resource, TemplateContext, AVAILABLE_SPECS};
+use ckb_resource::{AVAILABLE_SPECS, Resource, TemplateContext};
 
 use crate::{
     deprecate,
diff --git a/util/channel/src/lib.rs b/util/channel/src/lib.rs
index a250f5f104..5389a24fe2 100644
--- a/util/channel/src/lib.rs
+++ b/util/channel/src/lib.rs
@@ -1,7 +1,7 @@
 //! Reexports `crossbeam_channel` to uniform the dependency version.
 pub use crossbeam_channel::{
-    after, bounded, select, tick, unbounded, Receiver, RecvError, RecvTimeoutError, Select,
-    SendError, Sender, TrySendError,
+    Receiver, RecvError, RecvTimeoutError, Select, SendError, Sender, TrySendError, after, bounded,
+    select, tick, unbounded,
 };
 
 pub mod oneshot {
diff --git a/util/constant/src/latest_assume_valid_target.rs b/util/constant/src/latest_assume_valid_target.rs
index c1fd1a094c..dc226ed7f9 100644
--- a/util/constant/src/latest_assume_valid_target.rs
+++ b/util/constant/src/latest_assume_valid_target.rs
@@ -2,7 +2,6 @@
 //! by script: ./devtools/release/update_default_valid_target.sh
 //! Please don't modify them manually.
 
-
 /// sync config related to mainnet
 pub mod mainnet {
     /// Default assume valid target for mainnet, expect to be a block 60 days ago.
diff --git a/util/crypto/src/secp/generator.rs b/util/crypto/src/secp/generator.rs
index 7ef84bd6f6..945c29c4ca 100644
--- a/util/crypto/src/secp/generator.rs
+++ b/util/crypto/src/secp/generator.rs
@@ -1,6 +1,6 @@
+use super::SECP256K1;
 use super::privkey::Privkey;
 use super::pubkey::Pubkey;
-use super::SECP256K1;
 use rand::{self, Rng, SeedableRng};
 use secp256k1::{PublicKey, SecretKey};
 
diff --git a/util/crypto/src/secp/pubkey.rs b/util/crypto/src/secp/pubkey.rs
index 279901adaf..49dc67fab1 100644
--- a/util/crypto/src/secp/pubkey.rs
+++ b/util/crypto/src/secp/pubkey.rs
@@ -1,7 +1,7 @@
-use super::error::Error;
-use super::signature::Signature;
 use super::Message;
 use super::SECP256K1;
+use super::error::Error;
+use super::signature::Signature;
 use ckb_fixed_hash::H512;
 use secp256k1::Message as SecpMessage;
 use secp256k1::PublicKey;
diff --git a/util/crypto/src/secp/signature.rs b/util/crypto/src/secp/signature.rs
index 1e7e64b265..1bcdcc889f 100644
--- a/util/crypto/src/secp/signature.rs
+++ b/util/crypto/src/secp/signature.rs
@@ -1,11 +1,11 @@
-use super::error::Error;
-use super::pubkey::Pubkey;
 use super::Message;
 use super::SECP256K1;
-use ckb_fixed_hash::{h256, H256, H520};
+use super::error::Error;
+use super::pubkey::Pubkey;
+use ckb_fixed_hash::{H256, H520, h256};
 use faster_hex::hex_string;
-use secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
 use secp256k1::Message as SecpMessage;
+use secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
 use std::fmt;
 use std::str::FromStr;
 
diff --git a/util/dao/src/lib.rs b/util/dao/src/lib.rs
index a5d4d9b000..22720ac04a 100644
--- a/util/dao/src/lib.rs
+++ b/util/dao/src/lib.rs
@@ -2,13 +2,13 @@
 
 use byteorder::{ByteOrder, LittleEndian};
 use ckb_chain_spec::consensus::Consensus;
-use ckb_dao_utils::{extract_dao_data, pack_dao_data, DaoError};
+use ckb_dao_utils::{DaoError, extract_dao_data, pack_dao_data};
 use ckb_traits::{CellDataProvider, EpochProvider, HeaderProvider};
 use ckb_types::{
     bytes::Bytes,
     core::{
-        cell::{CellMeta, ResolvedTransaction},
         Capacity, CapacityResult, EpochExt, HeaderView, ScriptHashType,
+        cell::{CellMeta, ResolvedTransaction},
     },
     packed::{Byte32, CellOutput, Script, WitnessArgs},
     prelude::*,
diff --git a/util/dao/src/tests.rs b/util/dao/src/tests.rs
index bbb4c2cf36..d555ec45f3 100644
--- a/util/dao/src/tests.rs
+++ b/util/dao/src/tests.rs
@@ -4,18 +4,17 @@ use ckb_db::RocksDB;
 use ckb_db_schema::COLUMNS;
 use ckb_store::{ChainDB, ChainStore};
 use ckb_types::{
+    U256,
     bytes::Bytes,
     core::{
-        capacity_bytes,
-        cell::{CellMetaBuilder, ResolvedTransaction},
         BlockBuilder, BlockNumber, Capacity, EpochExt, EpochNumberWithFraction, HeaderBuilder,
-        HeaderView, TransactionBuilder,
+        HeaderView, TransactionBuilder, capacity_bytes,
+        cell::{CellMetaBuilder, ResolvedTransaction},
     },
     h256,
     packed::CellOutput,
     prelude::*,
     utilities::DIFF_TWO,
-    U256,
 };
 use tempfile::TempDir;
 
diff --git a/util/dao/utils/src/error.rs b/util/dao/utils/src/error.rs
index 2658ee9eb2..c3ac83caa7 100644
--- a/util/dao/utils/src/error.rs
+++ b/util/dao/utils/src/error.rs
@@ -1,4 +1,4 @@
-use ckb_error::{prelude::*, Error, ErrorKind};
+use ckb_error::{Error, ErrorKind, prelude::*};
 use ckb_types::core::CapacityError;
 
 /// Errors due to the fact that the NervosDAO rules are not respected.
diff --git a/util/dao/utils/src/lib.rs b/util/dao/utils/src/lib.rs
index 3e67098a43..22d64109c2 100644
--- a/util/dao/utils/src/lib.rs
+++ b/util/dao/utils/src/lib.rs
@@ -4,10 +4,10 @@ mod error;
 
 use byteorder::{ByteOrder, LittleEndian};
 use ckb_types::{
-    core::{capacity_bytes, Capacity, Ratio, TransactionView},
+    H160,
+    core::{Capacity, Ratio, TransactionView, capacity_bytes},
     packed::{Byte32, OutPoint},
     prelude::*,
-    H160,
 };
 use std::collections::HashSet;
 
diff --git a/util/fee-estimator/src/estimator/confirmation_fraction.rs b/util/fee-estimator/src/estimator/confirmation_fraction.rs
index 06a4fc49a3..d055796772 100644
--- a/util/fee-estimator/src/estimator/confirmation_fraction.rs
+++ b/util/fee-estimator/src/estimator/confirmation_fraction.rs
@@ -10,13 +10,13 @@ use std::{
 
 use ckb_types::{
     core::{
-        tx_pool::{get_transaction_weight, TxEntryInfo},
         BlockNumber, BlockView, FeeRate,
+        tx_pool::{TxEntryInfo, get_transaction_weight},
     },
     packed::Byte32,
 };
 
-use crate::{constants, Error};
+use crate::{Error, constants};
 
 /// The number of blocks that the esitmator will trace the statistics.
 const MAX_CONFIRM_BLOCKS: usize = 1000;
diff --git a/util/fee-estimator/src/estimator/mod.rs b/util/fee-estimator/src/estimator/mod.rs
index 3c877beca8..8e8fd43882 100644
--- a/util/fee-estimator/src/estimator/mod.rs
+++ b/util/fee-estimator/src/estimator/mod.rs
@@ -2,14 +2,14 @@ use std::sync::Arc;
 
 use ckb_types::{
     core::{
-        tx_pool::{TxEntryInfo, TxPoolEntryInfo},
         BlockNumber, BlockView, EstimateMode, FeeRate,
+        tx_pool::{TxEntryInfo, TxPoolEntryInfo},
     },
     packed::Byte32,
 };
 use ckb_util::RwLock;
 
-use crate::{constants, Error};
+use crate::{Error, constants};
 
 mod confirmation_fraction;
 mod weight_units_flow;
diff --git a/util/fee-estimator/src/estimator/weight_units_flow.rs b/util/fee-estimator/src/estimator/weight_units_flow.rs
index 39b549e388..9ca77536f8 100644
--- a/util/fee-estimator/src/estimator/weight_units_flow.rs
+++ b/util/fee-estimator/src/estimator/weight_units_flow.rs
@@ -56,11 +56,11 @@ use std::collections::HashMap;
 
 use ckb_chain_spec::consensus::MAX_BLOCK_BYTES;
 use ckb_types::core::{
-    tx_pool::{get_transaction_weight, TxEntryInfo, TxPoolEntryInfo},
     BlockNumber, BlockView, FeeRate,
+    tx_pool::{TxEntryInfo, TxPoolEntryInfo, get_transaction_weight},
 };
 
-use crate::{constants, Error};
+use crate::{Error, constants};
 
 const FEE_RATE_UNIT: u64 = 1000;
 
diff --git a/util/fixed-hash/core/src/impls.rs b/util/fixed-hash/core/src/impls.rs
index 58e1890d63..0f1c715422 100644
--- a/util/fixed-hash/core/src/impls.rs
+++ b/util/fixed-hash/core/src/impls.rs
@@ -1,4 +1,4 @@
-use crate::{error::FromSliceError, H160, H256, H512, H520};
+use crate::{H160, H256, H512, H520, error::FromSliceError};
 
 macro_rules! impl_methods {
     ($name:ident, $bytes_size:expr) => {
diff --git a/util/fixed-hash/core/src/std_str.rs b/util/fixed-hash/core/src/std_str.rs
index 664298d50c..b16fc945a5 100644
--- a/util/fixed-hash/core/src/std_str.rs
+++ b/util/fixed-hash/core/src/std_str.rs
@@ -1,4 +1,4 @@
-use crate::{error::FromStrError, H160, H256, H512, H520};
+use crate::{H160, H256, H512, H520, error::FromStrError};
 
 pub(crate) const DICT_HEX_ERROR: u8 = u8::MAX;
 pub(crate) static DICT_HEX_LO: [u8; 256] = {
diff --git a/util/fixed-hash/core/src/tests/impls.rs b/util/fixed-hash/core/src/tests/impls.rs
index a85d5f9046..b855909abe 100644
--- a/util/fixed-hash/core/src/tests/impls.rs
+++ b/util/fixed-hash/core/src/tests/impls.rs
@@ -1,4 +1,4 @@
-use crate::{error::FromSliceError, H160, H256, H512, H520};
+use crate::{H160, H256, H512, H520, error::FromSliceError};
 
 macro_rules! add_tests {
     ($test_name:ident, $type:ident, $bytes_size:literal) => {
diff --git a/util/fixed-hash/core/src/tests/std_str.rs b/util/fixed-hash/core/src/tests/std_str.rs
index 150cb55815..0eb96dd9e3 100644
--- a/util/fixed-hash/core/src/tests/std_str.rs
+++ b/util/fixed-hash/core/src/tests/std_str.rs
@@ -1,4 +1,4 @@
-use crate::{error::FromStrError, H160, H256, H512, H520};
+use crate::{H160, H256, H512, H520, error::FromStrError};
 use std::str::FromStr;
 
 macro_rules! test_from_trimmed_str_one_byte {
diff --git a/util/fixed-hash/src/lib.rs b/util/fixed-hash/src/lib.rs
index df1ab7e955..f895931bd9 100644
--- a/util/fixed-hash/src/lib.rs
+++ b/util/fixed-hash/src/lib.rs
@@ -18,7 +18,7 @@
 //! assert_eq!(ONE1, ONE2);
 //! ```
 
-pub use ckb_fixed_hash_core::{error, H160, H256, H512, H520};
+pub use ckb_fixed_hash_core::{H160, H256, H512, H520, error};
 
 #[doc(hidden)]
 pub use ckb_fixed_hash_macros as internal;
diff --git a/util/indexer-sync/src/custom_filters.rs b/util/indexer-sync/src/custom_filters.rs
index 6369db9912..839a1c12a0 100644
--- a/util/indexer-sync/src/custom_filters.rs
+++ b/util/indexer-sync/src/custom_filters.rs
@@ -3,7 +3,7 @@ use ckb_types::{
     packed::{Bytes, CellOutput},
 };
 use numext_fixed_uint::U256;
-use rhai::{Engine, EvalAltResult, Scope, AST};
+use rhai::{AST, Engine, EvalAltResult, Scope};
 
 /// Custom filters
 ///
diff --git a/util/indexer-sync/src/lib.rs b/util/indexer-sync/src/lib.rs
index b69121db56..b186dc2aa6 100644
--- a/util/indexer-sync/src/lib.rs
+++ b/util/indexer-sync/src/lib.rs
@@ -12,8 +12,8 @@ pub use crate::store::SecondaryDB;
 
 use ckb_app_config::{DBConfig, IndexerSyncConfig};
 use ckb_async_runtime::{
-    tokio::{self, time},
     Handle,
+    tokio::{self, time},
 };
 use ckb_db_schema::{
     COLUMN_BLOCK_BODY, COLUMN_BLOCK_EXTENSION, COLUMN_BLOCK_HEADER, COLUMN_BLOCK_PROPOSAL_IDS,
@@ -21,13 +21,13 @@ use ckb_db_schema::{
 };
 use ckb_logger::{error, info};
 use ckb_notify::NotifyController;
-use ckb_stop_handler::{has_received_stop_signal, new_tokio_exit_rx, CancellationToken};
+use ckb_stop_handler::{CancellationToken, has_received_stop_signal, new_tokio_exit_rx};
 use ckb_store::ChainStore;
 use ckb_types::{
+    H256,
     core::{self, BlockNumber, BlockView},
     packed::Byte32,
     prelude::*,
-    H256,
 };
 use rocksdb::prelude::*;
 
@@ -270,24 +270,26 @@ impl IndexerSyncService {
         I: IndexerSync + Clone + Send + 'static,
     {
         let secondary_db = self.secondary_db.clone();
-        let check_index_tx_pool_ready = self.async_handle.spawn_blocking(move || loop {
-            if has_received_stop_signal() {
-                info!("check_index_tx_pool_ready received exit signal, exit now");
-                break;
-            }
-
-            if let Err(e) = secondary_db.try_catch_up_with_primary() {
-                error!("secondary_db try_catch_up_with_primary error {}", e);
-            }
-            if let (Some(header), Ok(Some((indexer_tip, _)))) =
-                (secondary_db.get_tip_header(), indexer_service.tip())
-            {
-                let node_tip = header.number();
-                if node_tip - indexer_tip <= INDEXER_NODE_TIP_GAP {
+        let check_index_tx_pool_ready = self.async_handle.spawn_blocking(move || {
+            loop {
+                if has_received_stop_signal() {
+                    info!("check_index_tx_pool_ready received exit signal, exit now");
                     break;
                 }
+
+                if let Err(e) = secondary_db.try_catch_up_with_primary() {
+                    error!("secondary_db try_catch_up_with_primary error {}", e);
+                }
+                if let (Some(header), Ok(Some((indexer_tip, _)))) =
+                    (secondary_db.get_tip_header(), indexer_service.tip())
+                {
+                    let node_tip = header.number();
+                    if node_tip - indexer_tip <= INDEXER_NODE_TIP_GAP {
+                        break;
+                    }
+                }
+                std::thread::sleep(Duration::from_secs(1));
             }
-            std::thread::sleep(Duration::from_secs(1));
         });
 
         self.pool_service
diff --git a/util/indexer-sync/src/pool.rs b/util/indexer-sync/src/pool.rs
index 72c0d3266f..066341ccf4 100644
--- a/util/indexer-sync/src/pool.rs
+++ b/util/indexer-sync/src/pool.rs
@@ -1,12 +1,12 @@
 //! An overlay to index the pending txs in the ckb tx pool
 
 use ckb_async_runtime::{
-    tokio::{self, task::JoinHandle},
     Handle,
+    tokio::{self, task::JoinHandle},
 };
 use ckb_logger::info;
 use ckb_notify::NotifyController;
-use ckb_stop_handler::{new_tokio_exit_rx, CancellationToken};
+use ckb_stop_handler::{CancellationToken, new_tokio_exit_rx};
 use ckb_types::{core::TransactionView, packed::OutPoint};
 
 use std::collections::HashSet;
diff --git a/util/indexer-sync/src/store.rs b/util/indexer-sync/src/store.rs
index 04bd03fb9b..90e1495656 100644
--- a/util/indexer-sync/src/store.rs
+++ b/util/indexer-sync/src/store.rs
@@ -3,8 +3,8 @@ use crate::error::Error;
 use ckb_db_schema::Col;
 use ckb_store::{ChainStore, Freezer, StoreCache};
 use rocksdb::{
-    ops::OpenCF, prelude::*, ColumnFamilyDescriptor, DBIterator, DBPinnableSlice, IteratorMode,
-    SecondaryDB as SecondaryRocksDB, SecondaryOpenDescriptor,
+    ColumnFamilyDescriptor, DBIterator, DBPinnableSlice, IteratorMode,
+    SecondaryDB as SecondaryRocksDB, SecondaryOpenDescriptor, ops::OpenCF, prelude::*,
 };
 use std::path::Path;
 use std::sync::Arc;
diff --git a/util/indexer/src/indexer.rs b/util/indexer/src/indexer.rs
index 1062b4b370..c1403edb57 100644
--- a/util/indexer/src/indexer.rs
+++ b/util/indexer/src/indexer.rs
@@ -933,13 +933,13 @@ mod tests {
     use super::*;
     use crate::store::RocksdbStore;
     use ckb_types::{
+        H256,
         bytes::Bytes,
         core::{
-            capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder,
-            ScriptHashType, TransactionBuilder,
+            BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder, ScriptHashType,
+            TransactionBuilder, capacity_bytes,
         },
         packed::{CellInput, CellOutputBuilder, OutPoint, ScriptBuilder},
-        H256,
     };
 
     const KEEP_NUM: u64 = 10;
diff --git a/util/indexer/src/service.rs b/util/indexer/src/service.rs
index 543692b733..291c970e35 100644
--- a/util/indexer/src/service.rs
+++ b/util/indexer/src/service.rs
@@ -1,6 +1,6 @@
 //！The indexer service.
 
-use crate::indexer::{self, extract_raw_data, Indexer, Key, KeyPrefix, Value};
+use crate::indexer::{self, Indexer, Key, KeyPrefix, Value, extract_raw_data};
 use crate::store::{IteratorDirection, RocksdbStore, Store};
 
 use ckb_app_config::IndexerConfig;
@@ -12,9 +12,9 @@ use ckb_jsonrpc_types::{
     IndexerTxWithCell, IndexerTxWithCells, JsonBytes, Uint32,
 };
 use ckb_notify::NotifyController;
-use ckb_types::{core, packed, prelude::*, H256};
+use ckb_types::{H256, core, packed, prelude::*};
 use memchr::memmem;
-use rocksdb::{prelude::*, Direction, IteratorMode};
+use rocksdb::{Direction, IteratorMode, prelude::*};
 
 use std::convert::TryInto;
 use std::num::NonZeroUsize;
@@ -921,13 +921,13 @@ mod tests {
     use ckb_indexer_sync::IndexerSync;
     use ckb_jsonrpc_types::{IndexerRange, IndexerSearchKeyFilter};
     use ckb_types::{
+        H256,
         bytes::Bytes,
         core::{
-            capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder,
-            ScriptHashType, TransactionBuilder,
+            BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder, ScriptHashType,
+            TransactionBuilder, capacity_bytes,
         },
         packed::{CellInput, CellOutputBuilder, OutPoint, Script, ScriptBuilder},
-        H256,
     };
     use faster_hex::hex_decode;
 
@@ -1265,7 +1265,11 @@ mod tests {
             )
             .unwrap();
 
-        assert_eq!(total_blocks as usize * 3 - 1, txs_page_1.objects.len() + txs_page_2.objects.len(), "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)");
+        assert_eq!(
+            total_blocks as usize * 3 - 1,
+            txs_page_1.objects.len() + txs_page_2.objects.len(),
+            "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)"
+        );
 
         let desc_txs_page_1 = rpc
             .get_transactions(
@@ -1290,7 +1294,11 @@ mod tests {
             )
             .unwrap();
 
-        assert_eq!(total_blocks as usize * 3 - 1, desc_txs_page_1.objects.len() + desc_txs_page_2.objects.len(), "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)");
+        assert_eq!(
+            total_blocks as usize * 3 - 1,
+            desc_txs_page_1.objects.len() + desc_txs_page_2.objects.len(),
+            "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)"
+        );
         assert_eq!(
             desc_txs_page_1.objects.first().unwrap().tx_hash(),
             txs_page_2.objects.last().unwrap().tx_hash()
@@ -1722,7 +1730,11 @@ mod tests {
             )
             .unwrap();
 
-        assert_eq!(total_blocks as usize * 3 - 1, txs.objects.len(), "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)");
+        assert_eq!(
+            total_blocks as usize * 3 - 1,
+            txs.objects.len(),
+            "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)"
+        );
 
         // test get_transactions rpc group by tx hash with exact search mode
         let txs = rpc
diff --git a/util/indexer/src/store/rocksdb.rs b/util/indexer/src/store/rocksdb.rs
index 5d7c7fe441..29c46bd228 100644
--- a/util/indexer/src/store/rocksdb.rs
+++ b/util/indexer/src/store/rocksdb.rs
@@ -1,6 +1,6 @@
 use super::{Batch, IteratorDirection, IteratorItem, Store};
 use ckb_indexer_sync::Error;
-use rocksdb::{prelude::*, Direction, IteratorMode, WriteBatch, DB};
+use rocksdb::{DB, Direction, IteratorMode, WriteBatch, prelude::*};
 use std::path::Path;
 use std::sync::Arc;
 
diff --git a/util/jsonrpc-types/src/alert.rs b/util/jsonrpc-types/src/alert.rs
index 7f63cfed1f..d70ead07f6 100644
--- a/util/jsonrpc-types/src/alert.rs
+++ b/util/jsonrpc-types/src/alert.rs
@@ -1,4 +1,4 @@
-use crate::{bytes::JsonBytes, Timestamp, Uint32};
+use crate::{Timestamp, Uint32, bytes::JsonBytes};
 use ckb_types::{packed, prelude::*};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
diff --git a/util/jsonrpc-types/src/block_template.rs b/util/jsonrpc-types/src/block_template.rs
index 8e49f9bf72..32855ffc44 100644
--- a/util/jsonrpc-types/src/block_template.rs
+++ b/util/jsonrpc-types/src/block_template.rs
@@ -2,7 +2,7 @@ use crate::{
     BlockNumber, Byte32, Cycle, EpochNumberWithFraction, Header, JsonBytes, ProposalShortId,
     Timestamp, Transaction, Uint32, Uint64, Version,
 };
-use ckb_types::{packed, prelude::*, H256};
+use ckb_types::{H256, packed, prelude::*};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::convert::From;
diff --git a/util/jsonrpc-types/src/blockchain.rs b/util/jsonrpc-types/src/blockchain.rs
index e5812d1d9e..0fe3382f72 100644
--- a/util/jsonrpc-types/src/blockchain.rs
+++ b/util/jsonrpc-types/src/blockchain.rs
@@ -1,12 +1,12 @@
 use crate::bytes::JsonBytes;
 use crate::{
     BlockNumber, Byte32, Capacity, Cycle, DeploymentPos, EpochNumber, EpochNumberWithFraction,
-    ProposalShortId, ResponseFormat, ResponseFormatInnerType, Timestamp, Uint128, Uint32, Uint64,
+    ProposalShortId, ResponseFormat, ResponseFormatInnerType, Timestamp, Uint32, Uint64, Uint128,
     Version,
 };
 use ckb_types::core::tx_pool;
 use ckb_types::utilities::MerkleProof as RawMerkleProof;
-use ckb_types::{core, packed, prelude::*, H256};
+use ckb_types::{H256, core, packed, prelude::*};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
diff --git a/util/jsonrpc-types/src/cell.rs b/util/jsonrpc-types/src/cell.rs
index 5c7dba6a1d..2caad4929f 100644
--- a/util/jsonrpc-types/src/cell.rs
+++ b/util/jsonrpc-types/src/cell.rs
@@ -1,8 +1,8 @@
 use crate::{CellOutput, JsonBytes};
 use ckb_types::{
+    H256,
     core::cell::{CellMeta, CellStatus},
     prelude::Unpack,
-    H256,
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
diff --git a/util/jsonrpc-types/src/json_schema.rs b/util/jsonrpc-types/src/json_schema.rs
index 5e51a75b65..6406cc0882 100644
--- a/util/jsonrpc-types/src/json_schema.rs
+++ b/util/jsonrpc-types/src/json_schema.rs
@@ -1,4 +1,4 @@
-use crate::{Byte32, Uint128, Uint32, Uint64};
+use crate::{Byte32, Uint32, Uint64, Uint128};
 use schemars::JsonSchema;
 
 macro_rules! impl_json_schema_for_type {
diff --git a/util/jsonrpc-types/src/lib.rs b/util/jsonrpc-types/src/lib.rs
index c05ab01db6..0d7b654042 100644
--- a/util/jsonrpc-types/src/lib.rs
+++ b/util/jsonrpc-types/src/lib.rs
@@ -53,7 +53,7 @@ pub use self::pool::{
 };
 pub use self::proposal_short_id::ProposalShortId;
 pub use self::subscription::Topic;
-pub use self::uints::{Uint128, Uint32, Uint64};
+pub use self::uints::{Uint32, Uint64, Uint128};
 pub use ckb_types::core::RationalU256;
 pub use indexer::{
     IndexerCell, IndexerCellType, IndexerCellsCapacity, IndexerOrder, IndexerPagination,
diff --git a/util/jsonrpc-types/src/net.rs b/util/jsonrpc-types/src/net.rs
index 9184180ba1..7286940744 100644
--- a/util/jsonrpc-types/src/net.rs
+++ b/util/jsonrpc-types/src/net.rs
@@ -1,4 +1,4 @@
-use crate::{BlockNumber, Byte32, Timestamp, Uint128, Uint64};
+use crate::{BlockNumber, Byte32, Timestamp, Uint64, Uint128};
 use ckb_types::H256;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
diff --git a/util/jsonrpc-types/src/pool.rs b/util/jsonrpc-types/src/pool.rs
index b3d9ea8c7a..7ca01e082b 100644
--- a/util/jsonrpc-types/src/pool.rs
+++ b/util/jsonrpc-types/src/pool.rs
@@ -1,11 +1,11 @@
 use crate::{BlockNumber, Capacity, Cycle, Timestamp, TransactionView, Uint64};
+use ckb_types::H256;
 use ckb_types::core::service::PoolTransactionEntry as CorePoolTransactionEntry;
 use ckb_types::core::tx_pool::{
     AncestorsScoreSortKey as CoreAncestorsScoreSortKey, PoolTxDetailInfo as CorePoolTxDetailInfo,
     Reject, TxEntryInfo, TxPoolEntryInfo, TxPoolIds as CoreTxPoolIds, TxPoolInfo as CoreTxPoolInfo,
 };
 use ckb_types::prelude::Unpack;
-use ckb_types::H256;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
diff --git a/util/jsonrpc-types/src/uints.rs b/util/jsonrpc-types/src/uints.rs
index 920b325305..7efec816b5 100644
--- a/util/jsonrpc-types/src/uints.rs
+++ b/util/jsonrpc-types/src/uints.rs
@@ -3,8 +3,8 @@ use ckb_types::{
     prelude::{Pack, Unpack},
 };
 use serde::{
-    de::{Error, Visitor},
     Deserialize, Deserializer, Serialize, Serializer,
+    de::{Error, Visitor},
 };
 use std::{fmt, marker, num};
 
diff --git a/util/launcher/src/lib.rs b/util/launcher/src/lib.rs
index 8bf7105b16..afd1bbff5f 100644
--- a/util/launcher/src/lib.rs
+++ b/util/launcher/src/lib.rs
@@ -15,8 +15,8 @@ use ckb_light_client_protocol_server::LightClientProtocol;
 use ckb_logger::info;
 use ckb_logger::internal::warn;
 use ckb_network::{
-    network::TransportType, observe_listen_port_occupancy, CKBProtocol, Flags, NetworkController,
-    NetworkService, NetworkState, SupportProtocols,
+    CKBProtocol, Flags, NetworkController, NetworkService, NetworkState, SupportProtocols,
+    network::TransportType, observe_listen_port_occupancy,
 };
 use ckb_network_alert::alert_relayer::AlertRelayer;
 use ckb_resource::Resource;
@@ -165,7 +165,8 @@ impl Launcher {
                 "chain_spec_hash mismatch: Config({}), storage({}). \
                     If the two chains are compatible, pass command line argument --skip-spec-check; \
                     otherwise, pass --overwrite-spec to enforce overriding the stored chain spec with the configured one.",
-                self.args.chain_spec_hash, stored_spec_hash.expect("checked")
+                self.args.chain_spec_hash,
+                stored_spec_hash.expect("checked")
             );
             return Err(ExitCode::Config);
         }
diff --git a/util/light-client-protocol-server/src/components/get_blocks_proof.rs b/util/light-client-protocol-server/src/components/get_blocks_proof.rs
index 991852309c..b119e2f24b 100644
--- a/util/light-client-protocol-server/src/components/get_blocks_proof.rs
+++ b/util/light-client-protocol-server/src/components/get_blocks_proof.rs
@@ -5,7 +5,7 @@ use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_store::ChainStore;
 use ckb_types::{packed, prelude::*};
 
-use crate::{constant, LightClientProtocol, Status, StatusCode};
+use crate::{LightClientProtocol, Status, StatusCode, constant};
 
 pub(crate) struct GetBlocksProofProcess<'a> {
     message: packed::GetBlocksProofReader<'a>,
diff --git a/util/light-client-protocol-server/src/components/get_last_state.rs b/util/light-client-protocol-server/src/components/get_last_state.rs
index d6bc3791a7..929728c3b6 100644
--- a/util/light-client-protocol-server/src/components/get_last_state.rs
+++ b/util/light-client-protocol-server/src/components/get_last_state.rs
@@ -1,7 +1,7 @@
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_types::{packed, prelude::*};
 
-use crate::{prelude::*, LightClientProtocol, Status, StatusCode};
+use crate::{LightClientProtocol, Status, StatusCode, prelude::*};
 
 pub(crate) struct GetLastStateProcess<'a> {
     message: packed::GetLastStateReader<'a>,
diff --git a/util/light-client-protocol-server/src/components/get_last_state_proof.rs b/util/light-client-protocol-server/src/components/get_last_state_proof.rs
index c64592db89..d505e623b2 100644
--- a/util/light-client-protocol-server/src/components/get_last_state_proof.rs
+++ b/util/light-client-protocol-server/src/components/get_last_state_proof.rs
@@ -1,12 +1,12 @@
-use std::cmp::{min, Ordering};
+use std::cmp::{Ordering, min};
 
 use ckb_merkle_mountain_range::leaf_index_to_pos;
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_shared::Snapshot;
 use ckb_store::ChainStore;
-use ckb_types::{core::BlockNumber, packed, prelude::*, U256};
+use ckb_types::{U256, core::BlockNumber, packed, prelude::*};
 
-use crate::{constant, LightClientProtocol, Status, StatusCode};
+use crate::{LightClientProtocol, Status, StatusCode, constant};
 
 pub(crate) struct GetLastStateProofProcess<'a> {
     message: packed::GetLastStateProofReader<'a>,
@@ -296,8 +296,8 @@ impl<'a> GetLastStateProofProcess<'a> {
                 num
             } else {
                 let errmsg = format!(
-                        "the difficulty boundary ({difficulty_boundary:#x}) is not in the block range [{start_block_number}, {last_block_number})"
-                    );
+                    "the difficulty boundary ({difficulty_boundary:#x}) is not in the block range [{start_block_number}, {last_block_number})"
+                );
                 return StatusCode::InvaildDifficultyBoundary.with_context(errmsg);
             };
 
@@ -319,8 +319,8 @@ impl<'a> GetLastStateProofProcess<'a> {
                         .collect();
                 } else {
                     let errmsg = format!(
-                            "the total difficulty for block#{difficulty_boundary_block_number} is not found"
-                        );
+                        "the total difficulty for block#{difficulty_boundary_block_number} is not found"
+                    );
                     return StatusCode::InternalError.with_context(errmsg);
                 };
                 match sampler.get_block_numbers_via_difficulties(
diff --git a/util/light-client-protocol-server/src/components/get_transactions_proof.rs b/util/light-client-protocol-server/src/components/get_transactions_proof.rs
index 1dd5700b53..9b633c98b6 100644
--- a/util/light-client-protocol-server/src/components/get_transactions_proof.rs
+++ b/util/light-client-protocol-server/src/components/get_transactions_proof.rs
@@ -5,7 +5,7 @@ use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_store::ChainStore;
 use ckb_types::{packed, prelude::*, utilities::CBMT};
 
-use crate::{constant, LightClientProtocol, Status, StatusCode};
+use crate::{LightClientProtocol, Status, StatusCode, constant};
 
 pub(crate) struct GetTransactionsProofProcess<'a> {
     message: packed::GetTransactionsProofReader<'a>,
diff --git a/util/light-client-protocol-server/src/components/tests/get_last_state_proof.rs b/util/light-client-protocol-server/src/components/tests/get_last_state_proof.rs
index 9032e0d7e9..d4a1e554ad 100644
--- a/util/light-client-protocol-server/src/components/tests/get_last_state_proof.rs
+++ b/util/light-client-protocol-server/src/components/tests/get_last_state_proof.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use ckb_types::{core::BlockNumber, U256};
+use ckb_types::{U256, core::BlockNumber};
 
 use super::super::get_last_state_proof::FindBlocksViaDifficulties;
 
diff --git a/util/light-client-protocol-server/src/lib.rs b/util/light-client-protocol-server/src/lib.rs
index d2e6bd938e..b0da2e8db1 100644
--- a/util/light-client-protocol-server/src/lib.rs
+++ b/util/light-client-protocol-server/src/lib.rs
@@ -5,7 +5,7 @@
 use std::sync::Arc;
 
 use ckb_logger::{debug, error, info, trace, warn};
-use ckb_network::{async_trait, bytes::Bytes, CKBProtocolContext, CKBProtocolHandler, PeerIndex};
+use ckb_network::{CKBProtocolContext, CKBProtocolHandler, PeerIndex, async_trait, bytes::Bytes};
 use ckb_shared::Shared;
 use ckb_store::ChainStore;
 use ckb_types::{core, packed, prelude::*};
diff --git a/util/light-client-protocol-server/src/tests/prelude.rs b/util/light-client-protocol-server/src/tests/prelude.rs
index 4387545934..dd949910e0 100644
--- a/util/light-client-protocol-server/src/tests/prelude.rs
+++ b/util/light-client-protocol-server/src/tests/prelude.rs
@@ -1,11 +1,11 @@
 use ckb_shared::Snapshot;
 use ckb_store::ChainStore;
 use ckb_types::{
+    U256,
     core::{BlockExt, BlockNumber, BlockView, HeaderView},
     packed,
     prelude::*,
     utilities::compact_to_difficulty,
-    U256,
 };
 
 #[allow(dead_code)]
@@ -17,7 +17,7 @@ pub(crate) trait SnapshotExt {
     fn get_block_ext_by_number(&self, num: BlockNumber) -> Option<BlockExt>;
 
     fn get_verifiable_header_by_number(&self, num: BlockNumber)
-        -> Option<packed::VerifiableHeader>;
+    -> Option<packed::VerifiableHeader>;
 
     fn get_block_difficulty_by_number(&self, num: BlockNumber) -> Option<U256> {
         self.get_header_by_number(num)
diff --git a/util/light-client-protocol-server/src/tests/utils/chain.rs b/util/light-client-protocol-server/src/tests/utils/chain.rs
index 94777dfa67..1efb301360 100644
--- a/util/light-client-protocol-server/src/tests/utils/chain.rs
+++ b/util/light-client-protocol-server/src/tests/utils/chain.rs
@@ -4,11 +4,11 @@ use std::{
 };
 
 use ckb_app_config::{BlockAssemblerConfig, NetworkConfig};
-use ckb_chain::{start_chain_services, ChainController};
-use ckb_chain_spec::consensus::{build_genesis_epoch_ext, ConsensusBuilder};
+use ckb_chain::{ChainController, start_chain_services};
+use ckb_chain_spec::consensus::{ConsensusBuilder, build_genesis_epoch_ext};
 use ckb_dao_utils::genesis_dao_data;
 use ckb_jsonrpc_types::ScriptHashType;
-use ckb_network::{network::TransportType, Flags, NetworkController, NetworkService, NetworkState};
+use ckb_network::{Flags, NetworkController, NetworkService, NetworkState, network::TransportType};
 use ckb_shared::{Shared, SharedBuilder};
 use ckb_systemtime::unix_time_as_millis;
 use ckb_test_chain_utils::always_success_cell;
@@ -20,7 +20,7 @@ use ckb_types::{
     utilities::DIFF_TWO,
 };
 
-use crate::{tests::prelude::*, LightClientProtocol};
+use crate::{LightClientProtocol, tests::prelude::*};
 
 pub(crate) struct MockChain {
     chain_controller: ChainController,
diff --git a/util/light-client-protocol-server/src/tests/utils/network_context.rs b/util/light-client-protocol-server/src/tests/utils/network_context.rs
index 736c07ea14..4416585dd3 100644
--- a/util/light-client-protocol-server/src/tests/utils/network_context.rs
+++ b/util/light-client-protocol-server/src/tests/utils/network_context.rs
@@ -6,8 +6,8 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use ckb_network::{
-    async_trait, bytes::Bytes as P2pBytes, Behaviour, CKBProtocolContext, Error, Peer, PeerIndex,
-    ProtocolId, SupportProtocols, TargetSession,
+    Behaviour, CKBProtocolContext, Error, Peer, PeerIndex, ProtocolId, SupportProtocols,
+    TargetSession, async_trait, bytes::Bytes as P2pBytes,
 };
 
 struct MockProtocolContext {
diff --git a/util/logger-service/src/lib.rs b/util/logger-service/src/lib.rs
index 7f651e4766..f512e99438 100644
--- a/util/logger-service/src/lib.rs
+++ b/util/logger-service/src/lib.rs
@@ -11,12 +11,12 @@ use std::path::{Path, PathBuf};
 use std::sync::OnceLock;
 use std::{fs, panic, process, sync, thread};
 use time::{
-    format_description::{self, FormatItem},
     OffsetDateTime,
+    format_description::{self, FormatItem},
 };
 
 use ckb_logger_config::Config;
-use ckb_util::{strings, Mutex, RwLock};
+use ckb_util::{Mutex, RwLock, strings};
 use yansi::Paint;
 
 #[cfg(test)]
diff --git a/util/metrics-service/src/lib.rs b/util/metrics-service/src/lib.rs
index ca6e4505db..2017aaa1dc 100644
--- a/util/metrics-service/src/lib.rs
+++ b/util/metrics-service/src/lib.rs
@@ -4,8 +4,8 @@ use std::net::SocketAddr;
 
 use http_body_util::Full;
 use hyper::{
-    body::Bytes, header::CONTENT_TYPE, service::service_fn, Error as HyperError, Method, Request,
-    Response,
+    Error as HyperError, Method, Request, Response, body::Bytes, header::CONTENT_TYPE,
+    service::service_fn,
 };
 use hyper_util::{
     rt::TokioExecutor,
@@ -17,7 +17,7 @@ use tokio::net::TcpListener;
 use ckb_async_runtime::Handle;
 use ckb_logger::info;
 use ckb_metrics_config::{Config, Exporter, Target};
-use ckb_stop_handler::{new_tokio_exit_rx, CancellationToken};
+use ckb_stop_handler::{CancellationToken, new_tokio_exit_rx};
 use ckb_util::strings;
 
 /// Ensures the metrics service can shutdown gracefully.
diff --git a/util/migrate/src/migrate.rs b/util/migrate/src/migrate.rs
index 6446d4b37d..58fb2dd09b 100644
--- a/util/migrate/src/migrate.rs
+++ b/util/migrate/src/migrate.rs
@@ -3,7 +3,7 @@
 use crate::migrations;
 use ckb_db::{ReadOnlyDB, RocksDB};
 use ckb_db_migration::{DefaultMigration, Migrations};
-use ckb_db_schema::{COLUMNS, COLUMN_META};
+use ckb_db_schema::{COLUMN_META, COLUMNS};
 use ckb_error::Error;
 use ckb_types::core::hardfork::HardForks;
 use std::cmp::Ordering;
diff --git a/util/migrate/src/tests.rs b/util/migrate/src/tests.rs
index f8335c6fc0..9fe2600384 100644
--- a/util/migrate/src/tests.rs
+++ b/util/migrate/src/tests.rs
@@ -10,7 +10,7 @@ use ckb_db_schema::{
 use ckb_systemtime::unix_time_as_millis;
 use ckb_types::{
     core::{
-        capacity_bytes, hardfork::HardForks, BlockBuilder, BlockExt, Capacity, TransactionBuilder,
+        BlockBuilder, BlockExt, Capacity, TransactionBuilder, capacity_bytes, hardfork::HardForks,
     },
     packed::{self, Bytes},
     prelude::*,
diff --git a/util/multisig/src/tests/secp256k1.rs b/util/multisig/src/tests/secp256k1.rs
index c5c59d1a3e..5c7f230e50 100644
--- a/util/multisig/src/tests/secp256k1.rs
+++ b/util/multisig/src/tests/secp256k1.rs
@@ -1,5 +1,5 @@
 use ckb_crypto::secp::{Message, Privkey, Pubkey, Signature};
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 use std::collections::HashSet;
 
 use crate::{error::ErrorKind, secp256k1::verify_m_of_n};
diff --git a/util/network-alert/src/alert_relayer.rs b/util/network-alert/src/alert_relayer.rs
index e4b8f506c8..38ca5b93fb 100644
--- a/util/network-alert/src/alert_relayer.rs
+++ b/util/network-alert/src/alert_relayer.rs
@@ -6,13 +6,13 @@
 //! A cli to generate alert message,
 //! A config option to set alert messages to broadcast.
 //
+use crate::BAD_MESSAGE_BAN_TIME;
 use crate::notifier::Notifier;
 use crate::verifier::Verifier;
-use crate::BAD_MESSAGE_BAN_TIME;
 use ckb_app_config::NetworkAlertConfig;
 use ckb_logger::{debug, info, trace};
 use ckb_network::{
-    async_trait, bytes::Bytes, CKBProtocolContext, CKBProtocolHandler, PeerIndex, TargetSession,
+    CKBProtocolContext, CKBProtocolHandler, PeerIndex, TargetSession, async_trait, bytes::Bytes,
 };
 use ckb_notify::NotifyController;
 use ckb_types::{packed, prelude::*};
diff --git a/util/network-alert/src/tests/test_notifier.rs b/util/network-alert/src/tests/test_notifier.rs
index eb8b906537..088e350820 100644
--- a/util/network-alert/src/tests/test_notifier.rs
+++ b/util/network-alert/src/tests/test_notifier.rs
@@ -1,5 +1,5 @@
 use crate::notifier::Notifier;
-use ckb_async_runtime::{new_background_runtime, Handle};
+use ckb_async_runtime::{Handle, new_background_runtime};
 use ckb_notify::NotifyService;
 
 use ckb_types::{packed, prelude::*};
diff --git a/util/network-alert/src/verifier.rs b/util/network-alert/src/verifier.rs
index 5eddd9d6ba..2cedb28978 100644
--- a/util/network-alert/src/verifier.rs
+++ b/util/network-alert/src/verifier.rs
@@ -7,7 +7,7 @@
 use ckb_app_config::NetworkAlertConfig;
 use ckb_error::AnyError;
 use ckb_logger::{debug, trace};
-use ckb_multisig::secp256k1::{verify_m_of_n, Message, Pubkey, Signature};
+use ckb_multisig::secp256k1::{Message, Pubkey, Signature, verify_m_of_n};
 use ckb_types::{packed, prelude::*};
 use std::collections::HashSet;
 
diff --git a/util/occupied-capacity/macros/src/lib.rs b/util/occupied-capacity/macros/src/lib.rs
index c5f3f66188..e8192bcb5f 100644
--- a/util/occupied-capacity/macros/src/lib.rs
+++ b/util/occupied-capacity/macros/src/lib.rs
@@ -2,7 +2,7 @@
 extern crate proc_macro;
 
 use quote::quote;
-use syn::{parse_macro_input, Error as SynError};
+use syn::{Error as SynError, parse_macro_input};
 
 use ckb_occupied_capacity_core::Capacity;
 
diff --git a/util/rich-indexer/src/indexer/insert.rs b/util/rich-indexer/src/indexer/insert.rs
index 456f6ecd35..0a2b791bfa 100644
--- a/util/rich-indexer/src/indexer/insert.rs
+++ b/util/rich-indexer/src/indexer/insert.rs
@@ -12,9 +12,9 @@ use ckb_types::{
 };
 use sql_builder::SqlBuilder;
 use sqlx::{
+    Row, Transaction,
     any::{Any, AnyArguments, AnyRow},
     query::Query,
-    Row, Transaction,
 };
 
 use std::collections::HashSet;
@@ -291,7 +291,7 @@ pub(crate) async fn bulk_insert_output_table(
             tx_id.into(),
             row.0.into(),
             row.1.into(),
-            query_script_id(&row.2 .0, row.2 .1, &row.2 .2, tx)
+            query_script_id(&row.2.0, row.2.1, &row.2.2, tx)
                 .await?
                 .map_or(FieldValue::NoneBigInt, FieldValue::BigInt),
             type_script_id.map_or(FieldValue::NoneBigInt, FieldValue::BigInt),
diff --git a/util/rich-indexer/src/indexer/mod.rs b/util/rich-indexer/src/indexer/mod.rs
index 4bddaf1a9d..fdc7ed5673 100644
--- a/util/rich-indexer/src/indexer/mod.rs
+++ b/util/rich-indexer/src/indexer/mod.rs
@@ -4,15 +4,15 @@ mod remove;
 pub(crate) use insert::*;
 pub(crate) use remove::*;
 
-use crate::{service::SUBSCRIBER_NAME, store::SQLXPool, RichIndexerHandle};
+use crate::{RichIndexerHandle, service::SUBSCRIBER_NAME, store::SQLXPool};
 
 use ckb_async_runtime::Handle;
 use ckb_indexer_sync::{CustomFilters, Error, IndexerSync, Pool};
 use ckb_types::{
+    H256,
     core::{BlockNumber, BlockView, TransactionView},
     packed::Byte32,
     prelude::*,
-    H256,
 };
 use sqlx::{Any, Transaction};
 
diff --git a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells.rs b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells.rs
index ae17b25c56..5177d71204 100644
--- a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells.rs
+++ b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells.rs
@@ -10,8 +10,8 @@ use ckb_jsonrpc_types::{
 use ckb_jsonrpc_types::{IndexerScriptType, IndexerSearchMode};
 use ckb_types::packed::{CellOutputBuilder, OutPointBuilder, ScriptBuilder};
 use ckb_types::prelude::*;
-use sql_builder::{name, name::SqlName, SqlBuilder};
-use sqlx::{any::AnyRow, Row};
+use sql_builder::{SqlBuilder, name, name::SqlName};
+use sqlx::{Row, any::AnyRow};
 
 impl AsyncRichIndexerHandle {
     /// Get cells
diff --git a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells_capacity.rs b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells_capacity.rs
index 9b72ffff7c..f7c9bd6ee0 100644
--- a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells_capacity.rs
+++ b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells_capacity.rs
@@ -6,7 +6,7 @@ use ckb_indexer_sync::Error;
 use ckb_jsonrpc_types::{IndexerCellsCapacity, IndexerSearchKey};
 use ckb_jsonrpc_types::{IndexerScriptType, IndexerSearchMode};
 use ckb_types::prelude::*;
-use sql_builder::{name, name::SqlName, SqlBuilder};
+use sql_builder::{SqlBuilder, name, name::SqlName};
 use sqlx::Row;
 
 impl AsyncRichIndexerHandle {
diff --git a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_transactions.rs b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_transactions.rs
index 7b9b425455..a73781fdd2 100644
--- a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_transactions.rs
+++ b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_transactions.rs
@@ -8,8 +8,8 @@ use ckb_jsonrpc_types::{
     IndexerTxWithCells,
 };
 use ckb_jsonrpc_types::{IndexerOrder, IndexerPagination, IndexerSearchKey, JsonBytes, Uint32};
-use sql_builder::{name, name::SqlName, SqlBuilder};
-use sqlx::{any::Any, Row, Transaction};
+use sql_builder::{SqlBuilder, name, name::SqlName};
+use sqlx::{Row, Transaction, any::Any};
 
 impl AsyncRichIndexerHandle {
     /// Get transactions
diff --git a/util/rich-indexer/src/store.rs b/util/rich-indexer/src/store.rs
index f4decd8d99..237912afe9 100644
--- a/util/rich-indexer/src/store.rs
+++ b/util/rich-indexer/src/store.rs
@@ -1,13 +1,13 @@
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use ckb_app_config::{DBDriver, RichIndexerConfig};
 use futures::TryStreamExt;
-use include_dir::{include_dir, Dir};
+use include_dir::{Dir, include_dir};
 use log::LevelFilter;
 use sqlx::{
+    AnyPool, ConnectOptions, IntoArguments, Row, Transaction,
     any::{Any, AnyArguments, AnyConnectOptions, AnyPoolOptions, AnyRow},
     migrate::Migrator,
     query::{Query, QueryAs},
-    AnyPool, ConnectOptions, IntoArguments, Row, Transaction,
 };
 use std::sync::OnceLock;
 use tempfile::tempdir;
diff --git a/util/rich-indexer/src/tests/insert.rs b/util/rich-indexer/src/tests/insert.rs
index b48b5d0995..15810874ef 100644
--- a/util/rich-indexer/src/tests/insert.rs
+++ b/util/rich-indexer/src/tests/insert.rs
@@ -1,13 +1,13 @@
 use super::*;
 
 use ckb_types::{
+    H256,
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder,
-        ScriptHashType, TransactionBuilder,
+        BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder, ScriptHashType,
+        TransactionBuilder, capacity_bytes,
     },
     packed::{CellInput, CellOutputBuilder, OutPoint, Script, ScriptBuilder},
-    H256,
 };
 use tokio::test;
 
diff --git a/util/rich-indexer/src/tests/query.rs b/util/rich-indexer/src/tests/query.rs
index 6d9d73365b..433fc9c270 100644
--- a/util/rich-indexer/src/tests/query.rs
+++ b/util/rich-indexer/src/tests/query.rs
@@ -3,13 +3,13 @@ use super::*;
 use ckb_indexer_sync::{CustomFilters, Pool};
 use ckb_jsonrpc_types::{IndexerRange, IndexerSearchKeyFilter, IndexerTx};
 use ckb_types::{
+    H256,
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder,
-        ScriptHashType, TransactionBuilder,
+        BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder, ScriptHashType,
+        TransactionBuilder, capacity_bytes,
     },
     packed::{self, CellInput, CellOutputBuilder, OutPoint, Script, ScriptBuilder},
-    H256,
 };
 
 use std::sync::{Arc, RwLock};
@@ -882,7 +882,11 @@ async fn rpc() {
         .await
         .unwrap();
 
-    assert_eq!(total_blocks as usize * 3 - 1, txs_page_1.objects.len() + txs_page_2.objects.len(), "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)");
+    assert_eq!(
+        total_blocks as usize * 3 - 1,
+        txs_page_1.objects.len() + txs_page_2.objects.len(),
+        "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)"
+    );
 
     let desc_txs_page_1 = rpc
         .get_transactions(
@@ -909,7 +913,11 @@ async fn rpc() {
         .await
         .unwrap();
 
-    assert_eq!(total_blocks as usize * 3 - 1, desc_txs_page_1.objects.len() + desc_txs_page_2.objects.len(), "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)");
+    assert_eq!(
+        total_blocks as usize * 3 - 1,
+        desc_txs_page_1.objects.len() + desc_txs_page_2.objects.len(),
+        "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)"
+    );
     assert_eq!(
         desc_txs_page_1.objects.first().unwrap().tx_hash(),
         txs_page_2.objects.last().unwrap().tx_hash()
@@ -1312,10 +1320,10 @@ async fn script_search_mode_rpc() {
         .unwrap();
 
     assert_eq!(
-            total_blocks as usize + 2,
-            cells.objects.len(),
-            "total size should be cellbase cells count + 2 (last block live cell: lock_script1 and lock_script11)"
-        );
+        total_blocks as usize + 2,
+        cells.objects.len(),
+        "total size should be cellbase cells count + 2 (last block live cell: lock_script1 and lock_script11)"
+    );
 
     // test get_cells rpc with exact search mode
     let cells = rpc
@@ -1353,7 +1361,11 @@ async fn script_search_mode_rpc() {
         .await
         .unwrap();
 
-    assert_eq!(total_blocks as usize * 3 - 1, txs.objects.len(), "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)");
+    assert_eq!(
+        total_blocks as usize * 3 - 1,
+        txs.objects.len(),
+        "total size should be cellbase tx count + total_block * 2 - 1 (genesis block only has one tx)"
+    );
 
     // test get_transactions rpc group by tx hash with exact search mode
     let txs = rpc
diff --git a/util/runtime/src/native.rs b/util/runtime/src/native.rs
index 7c7a728f78..01efb5d96c 100644
--- a/util/runtime/src/native.rs
+++ b/util/runtime/src/native.rs
@@ -102,11 +102,7 @@ fn new_runtime(worker_num: Option<usize>) -> Runtime {
                     // When id wraps around, we couldn't know whether the old id
                     // is released or not.
                     // But we can ignore this, because it's almost impossible.
-                    if n >= 999_999 {
-                        Some(0)
-                    } else {
-                        Some(n + 1)
-                    }
+                    if n >= 999_999 { Some(0) } else { Some(n + 1) }
                 })
                 .expect("impossible since the above closure must return Some(number)");
             format!("GlobalRt-{id}")
diff --git a/util/snapshot/src/lib.rs b/util/snapshot/src/lib.rs
index b76e467e12..6d214cda1c 100644
--- a/util/snapshot/src/lib.rs
+++ b/util/snapshot/src/lib.rs
@@ -6,26 +6,26 @@ use ckb_chain_spec::{
     versionbits::{DeploymentPos, ThresholdState, VersionbitsIndexer},
 };
 use ckb_db::{
-    iter::{DBIter, IteratorMode},
     DBPinnableSlice,
+    iter::{DBIter, IteratorMode},
 };
 use ckb_db_schema::Col;
 use ckb_freezer::Freezer;
 use ckb_merkle_mountain_range::{
-    leaf_index_to_mmr_size, Error as MMRError, MMRStore, Result as MMRResult,
+    Error as MMRError, MMRStore, Result as MMRResult, leaf_index_to_mmr_size,
 };
 use ckb_proposal_table::ProposalView;
 use ckb_store::{ChainStore, StoreCache, StoreSnapshot};
 use ckb_traits::{HeaderFields, HeaderFieldsProvider, HeaderProvider};
 use ckb_types::core::error::OutPointError;
 use ckb_types::{
+    U256,
     core::{
-        cell::{CellChecker, CellProvider, CellStatus, HeaderChecker},
         BlockNumber, EpochExt, HeaderView, TransactionView, Version,
+        cell::{CellChecker, CellProvider, CellStatus, HeaderChecker},
     },
     packed::{Byte32, HeaderDigest, OutPoint},
     utilities::merkle_mountain_range::ChainRootMMR,
-    U256,
 };
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
diff --git a/util/src/tests/linked_hash_set.rs b/util/src/tests/linked_hash_set.rs
index f80cf6db87..2310044052 100644
--- a/util/src/tests/linked_hash_set.rs
+++ b/util/src/tests/linked_hash_set.rs
@@ -1,4 +1,4 @@
-use ckb_fixed_hash::{h256, H256};
+use ckb_fixed_hash::{H256, h256};
 
 use crate::LinkedHashSet;
 
diff --git a/util/stop-handler/src/tests.rs b/util/stop-handler/src/tests.rs
index fa747dca2d..84f4075467 100644
--- a/util/stop-handler/src/tests.rs
+++ b/util/stop-handler/src/tests.rs
@@ -2,11 +2,11 @@ use crate::{
     broadcast_exit_signals, new_crossbeam_exit_rx, new_tokio_exit_rx, register_thread,
     wait_all_ckb_services_exit,
 };
-use ckb_async_runtime::{new_global_runtime, Handle};
+use ckb_async_runtime::{Handle, new_global_runtime};
 use ckb_channel::select;
 use rand::Rng;
-use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicI64, Ordering};
 use std::time::Duration;
 use tokio_util::sync::CancellationToken;
 
diff --git a/util/test-chain-utils/src/chain.rs b/util/test-chain-utils/src/chain.rs
index 7535ea7de4..b449c19e1c 100644
--- a/util/test-chain-utils/src/chain.rs
+++ b/util/test-chain-utils/src/chain.rs
@@ -1,11 +1,12 @@
 use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_chain_spec::{
-    build_genesis_type_id_script, ChainSpec, OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL,
-    OUTPUT_INDEX_SECP256K1_DATA,
+    ChainSpec, OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL, OUTPUT_INDEX_SECP256K1_DATA,
+    build_genesis_type_id_script,
 };
 use ckb_dao_utils::genesis_dao_data;
 use ckb_resource::Resource;
 use ckb_types::{
+    H256, U256,
     bytes::Bytes,
     core::{
         BlockBuilder, BlockNumber, Capacity, EpochNumberWithFraction, ScriptHashType,
@@ -14,7 +15,6 @@ use ckb_types::{
     packed::{CellInput, CellOutput, OutPoint, Script},
     prelude::*,
     utilities::difficulty_to_compact,
-    H256, U256,
 };
 use std::fs::File;
 use std::io::Read;
diff --git a/util/test-chain-utils/src/lib.rs b/util/test-chain-utils/src/lib.rs
index b9322c56b6..48a25bea45 100644
--- a/util/test-chain-utils/src/lib.rs
+++ b/util/test-chain-utils/src/lib.rs
@@ -10,7 +10,7 @@ pub use chain::{
     is_even_lib, load_input_data_hash_cell, load_input_one_byte_cell, load_is_even,
     secp256k1_blake160_sighash_cell, secp256k1_data_cell, type_lock_script_code_hash,
 };
-pub use median_time::{MockMedianTime, MOCK_MEDIAN_TIME_COUNT};
+pub use median_time::{MOCK_MEDIAN_TIME_COUNT, MockMedianTime};
 pub use mock_chain::MockChain;
 pub use mock_store::MockStore;
 pub use mock_utils::{
diff --git a/util/test-chain-utils/src/mock_chain.rs b/util/test-chain-utils/src/mock_chain.rs
index 059d3b3729..0c93eda5d0 100644
--- a/util/test-chain-utils/src/mock_chain.rs
+++ b/util/test-chain-utils/src/mock_chain.rs
@@ -1,14 +1,14 @@
 #![allow(dead_code)]
 #![allow(missing_docs)]
 
-use crate::mock_utils::{create_cellbase, dao_data};
 use crate::MockStore;
+use crate::mock_utils::{create_cellbase, dao_data};
 use ckb_chain_spec::consensus::Consensus;
 use ckb_store::ChainStore;
 use ckb_types::core::{BlockBuilder, BlockView, HeaderView, TransactionView};
 use ckb_types::prelude::Pack;
 use ckb_types::utilities::difficulty_to_compact;
-use ckb_types::{packed, U256};
+use ckb_types::{U256, packed};
 
 #[derive(Clone)]
 pub struct MockChain<'a> {
diff --git a/util/test-chain-utils/src/mock_store.rs b/util/test-chain-utils/src/mock_store.rs
index 1686f7b453..720aa6fac3 100644
--- a/util/test-chain-utils/src/mock_store.rs
+++ b/util/test-chain-utils/src/mock_store.rs
@@ -5,8 +5,8 @@ use ckb_systemtime::unix_time_as_millis;
 use ckb_types::core::error::OutPointError;
 use ckb_types::{
     core::{
-        cell::{CellMetaBuilder, CellProvider, CellStatus, HeaderChecker},
         BlockExt, BlockView, EpochExt, HeaderView,
+        cell::{CellMetaBuilder, CellProvider, CellStatus, HeaderChecker},
     },
     packed::{Byte32, OutPoint},
     prelude::*,
diff --git a/util/test-chain-utils/src/mock_utils.rs b/util/test-chain-utils/src/mock_utils.rs
index 8b8c7be01f..3f42dc2922 100644
--- a/util/test-chain-utils/src/mock_utils.rs
+++ b/util/test-chain-utils/src/mock_utils.rs
@@ -9,9 +9,8 @@ use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes,
-        cell::{resolve_transaction, OverlayCellProvider, TransactionsProvider},
-        Capacity, HeaderView, TransactionBuilder, TransactionView,
+        Capacity, HeaderView, TransactionBuilder, TransactionView, capacity_bytes,
+        cell::{OverlayCellProvider, TransactionsProvider, resolve_transaction},
     },
     packed::{self, Byte32, CellDep, CellInput, CellOutputBuilder, OutPoint},
 };
@@ -20,7 +19,7 @@ use std::collections::HashSet;
 const MIN_CAP: Capacity = capacity_bytes!(60);
 
 pub fn create_always_success_tx() -> TransactionView {
-    let ( always_success_cell,  always_success_cell_data,  script) = always_success_cell();
+    let (always_success_cell, always_success_cell_data, script) = always_success_cell();
     TransactionBuilder::default()
         .witness(script.clone().into_witness())
         .input(CellInput::new(OutPoint::null(), 0))
@@ -30,7 +29,7 @@ pub fn create_always_success_tx() -> TransactionView {
 }
 
 pub fn create_load_input_data_hash_cell_tx() -> TransactionView {
-    let (load_input_data_hash_cell_cell,  load_input_data_hash_cell_data,  script) =
+    let (load_input_data_hash_cell_cell, load_input_data_hash_cell_data, script) =
         load_input_data_hash_cell();
     TransactionBuilder::default()
         .witness(script.clone().into_witness())
diff --git a/util/types/src/core/advanced_builders.rs b/util/types/src/core/advanced_builders.rs
index eae6b39a9e..fc2efd37b9 100644
--- a/util/types/src/core/advanced_builders.rs
+++ b/util/types/src/core/advanced_builders.rs
@@ -3,7 +3,7 @@
 use crate::{
     constants, core, packed,
     prelude::*,
-    utilities::{merkle_root, DIFF_TWO},
+    utilities::{DIFF_TWO, merkle_root},
 };
 
 /*
diff --git a/util/types/src/core/cell.rs b/util/types/src/core/cell.rs
index f1d8a02717..e852bd87ec 100644
--- a/util/types/src/core/cell.rs
+++ b/util/types/src/core/cell.rs
@@ -8,7 +8,7 @@ use crate::{
 };
 use ckb_error::Error;
 use ckb_occupied_capacity::Result as CapacityResult;
-use std::collections::{hash_map::Entry, HashMap, HashSet};
+use std::collections::{HashMap, HashSet, hash_map::Entry};
 use std::fmt;
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::sync::OnceLock;
diff --git a/util/types/src/core/error.rs b/util/types/src/core/error.rs
index 26978e9ded..59306d9f4e 100644
--- a/util/types/src/core/error.rs
+++ b/util/types/src/core/error.rs
@@ -4,7 +4,7 @@ use crate::{
     core::{Capacity, Version},
     packed::{Byte32, OutPoint},
 };
-use ckb_error::{impl_error_conversion_with_kind, prelude::*, Error, ErrorKind};
+use ckb_error::{Error, ErrorKind, impl_error_conversion_with_kind, prelude::*};
 use derive_more::Display;
 
 /// Errors due to the fact that the out-point rules are not respected.
@@ -65,7 +65,9 @@ pub enum TransactionErrorSource {
 #[derive(Error, Debug, PartialEq, Eq, Clone)]
 pub enum TransactionError {
     /// There is an erroneous output that its occupied capacity is greater than its capacity (`output.occupied_capacity() > output.capacity()`).
-    #[error("InsufficientCellCapacity({inner}[{index}]): expected occupied capacity ({occupied_capacity:#x}) <= capacity ({capacity:#x})")]
+    #[error(
+        "InsufficientCellCapacity({inner}[{index}]): expected occupied capacity ({occupied_capacity:#x}) <= capacity ({capacity:#x})"
+    )]
     InsufficientCellCapacity {
         /// The transaction field that causes error.
         /// It should always be `TransactionErrorSource::Outputs.`
@@ -79,7 +81,9 @@ pub enum TransactionError {
     },
 
     /// The total capacity of outputs is less than the total capacity of inputs (`SUM([o.capacity for o in outputs]) > SUM([i.capacity for i in inputs]`).
-    #[error("OutputsSumOverflow: expected outputs capacity ({outputs_sum:#x}) <= inputs capacity ({inputs_sum:#x})")]
+    #[error(
+        "OutputsSumOverflow: expected outputs capacity ({outputs_sum:#x}) <= inputs capacity ({inputs_sum:#x})"
+    )]
     OutputsSumOverflow {
         /// The total capacity of inputs.
         inputs_sum: Capacity,
@@ -114,7 +118,9 @@ pub enum TransactionError {
     },
 
     /// The length of outputs is not equal to the length of outputs-data (`outputs.len() != outputs_data.len()`).
-    #[error("OutputsDataLengthMismatch: expected outputs data length ({outputs_data_len}) = outputs length ({outputs_len})")]
+    #[error(
+        "OutputsDataLengthMismatch: expected outputs data length ({outputs_data_len}) = outputs length ({outputs_len})"
+    )]
     OutputsDataLengthMismatch {
         /// The length of outputs.
         outputs_len: usize,
@@ -162,7 +168,9 @@ pub enum TransactionError {
     },
 
     /// The transaction size exceeds limit.
-    #[error("ExceededMaximumBlockBytes: expected transaction serialized size ({actual}) < block size limit ({limit})")]
+    #[error(
+        "ExceededMaximumBlockBytes: expected transaction serialized size ({actual}) < block size limit ({limit})"
+    )]
     ExceededMaximumBlockBytes {
         /// The limited transaction size.
         limit: u64,
@@ -171,21 +179,28 @@ pub enum TransactionError {
     },
 
     /// The compatible error.
-    #[error("Compatible: the feature \"{feature}\" is used in current transaction, but not enabled in current chain")]
+    #[error(
+        "Compatible: the feature \"{feature}\" is used in current transaction, but not enabled in current chain"
+    )]
     Compatible {
         /// The feature name.
         feature: &'static str,
     },
 
     /// Nervos DAO lock size mismatch.
-    #[error("The lock script size of deposit cell at index {} does not match the withdrawing cell at the same index", index)]
+    #[error(
+        "The lock script size of deposit cell at index {} does not match the withdrawing cell at the same index",
+        index
+    )]
     DaoLockSizeMismatch {
         /// The index of mismatched DAO cells.
         index: usize,
     },
 
     /// The internal error.
-    #[error("Internal: {description}, this error shouldn't happen; please report this bug to developers.")]
+    #[error(
+        "Internal: {description}, this error shouldn't happen; please report this bug to developers."
+    )]
     Internal {
         /// The error description
         description: String,
diff --git a/util/types/src/core/extras.rs b/util/types/src/core/extras.rs
index a7261a2fb5..959ea55971 100644
--- a/util/types/src/core/extras.rs
+++ b/util/types/src/core/extras.rs
@@ -1,8 +1,8 @@
 use crate::{
+    U256,
     core::{BlockNumber, Capacity, CapacityResult, Cycle, EpochNumber},
     packed,
     prelude::*,
-    U256,
 };
 use ckb_rational::RationalU256;
 use std::cmp::Ordering;
diff --git a/util/types/src/core/hardfork/mod.rs b/util/types/src/core/hardfork/mod.rs
index b2229c83ec..016e90f326 100644
--- a/util/types/src/core/hardfork/mod.rs
+++ b/util/types/src/core/hardfork/mod.rs
@@ -5,8 +5,8 @@ pub(crate) mod helper;
 mod ckb2021;
 mod ckb2023;
 
-pub use ckb2021::{CKB2021Builder, CKB2021};
-pub use ckb2023::{CKB2023Builder, CKB2023};
+pub use ckb2021::{CKB2021, CKB2021Builder};
+pub use ckb2023::{CKB2023, CKB2023Builder};
 
 /// Hardfork-related configuration
 #[derive(Debug, Clone)]
diff --git a/util/types/src/core/mod.rs b/util/types/src/core/mod.rs
index 8b7fc8dcd1..2343723904 100644
--- a/util/types/src/core/mod.rs
+++ b/util/types/src/core/mod.rs
@@ -43,7 +43,7 @@ pub use views::{
 
 pub use ckb_gen_types::core::*;
 pub use ckb_occupied_capacity::{
-    capacity_bytes, Capacity, Error as CapacityError, Ratio, Result as CapacityResult,
+    Capacity, Error as CapacityError, Ratio, Result as CapacityResult, capacity_bytes,
 };
 pub use ckb_rational::RationalU256;
 
diff --git a/util/types/src/core/tests/cell.rs b/util/types/src/core/tests/cell.rs
index 28de967f24..d9c410367d 100644
--- a/util/types/src/core/tests/cell.rs
+++ b/util/types/src/core/tests/cell.rs
@@ -4,14 +4,13 @@ use std::collections::{HashMap, HashSet};
 use crate::{
     bytes::Bytes,
     core::{
-        capacity_bytes,
+        BlockBuilder, BlockView, Capacity, DepType, EpochNumberWithFraction, TransactionBuilder,
+        TransactionInfo, TransactionView, capacity_bytes,
         cell::{
-            resolve_transaction, BlockCellProvider, CellMeta, CellProvider, CellStatus,
-            HeaderChecker,
+            BlockCellProvider, CellMeta, CellProvider, CellStatus, HeaderChecker,
+            resolve_transaction,
         },
         error::OutPointError,
-        BlockBuilder, BlockView, Capacity, DepType, EpochNumberWithFraction, TransactionBuilder,
-        TransactionInfo, TransactionView,
     },
     h256,
     packed::{Byte32, CellDep, CellInput, CellOutput, OutPoint},
diff --git a/util/types/src/core/tests/fee_rate.rs b/util/types/src/core/tests/fee_rate.rs
index 85d4c30614..4a2fb194a4 100644
--- a/util/types/src/core/tests/fee_rate.rs
+++ b/util/types/src/core/tests/fee_rate.rs
@@ -1,4 +1,4 @@
-use crate::core::{capacity_bytes, Capacity, FeeRate};
+use crate::core::{Capacity, FeeRate, capacity_bytes};
 
 #[test]
 
diff --git a/util/types/src/core/tests/tx_pool.rs b/util/types/src/core/tests/tx_pool.rs
index 2b607001d4..fd25241d74 100644
--- a/util/types/src/core/tests/tx_pool.rs
+++ b/util/types/src/core/tests/tx_pool.rs
@@ -1,7 +1,7 @@
 use ckb_error::{ErrorKind, InternalErrorKind, OtherError, SilentError as DefaultError};
 
 use crate::core::{
-    error::{OutPointError, TransactionError, TransactionErrorSource, ARGV_TOO_LONG_TEXT},
+    error::{ARGV_TOO_LONG_TEXT, OutPointError, TransactionError, TransactionErrorSource},
     tx_pool::Reject,
 };
 
diff --git a/util/types/src/core/tx_pool.rs b/util/types/src/core/tx_pool.rs
index 9df8e3a8a9..0a09b20959 100644
--- a/util/types/src/core/tx_pool.rs
+++ b/util/types/src/core/tx_pool.rs
@@ -1,15 +1,14 @@
 //! Tx-pool shared type define.
 use crate::{
+    H256,
     core::{
-        self,
-        error::{OutPointError, TransactionError, ARGV_TOO_LONG_TEXT},
-        BlockNumber, Capacity, Cycle, FeeRate,
+        self, BlockNumber, Capacity, Cycle, FeeRate,
+        error::{ARGV_TOO_LONG_TEXT, OutPointError, TransactionError},
     },
     packed::Byte32,
-    H256,
 };
 use ckb_error::{
-    impl_error_conversion_with_kind, prelude::*, Error, ErrorKind, InternalError, InternalErrorKind,
+    Error, ErrorKind, InternalError, InternalErrorKind, impl_error_conversion_with_kind, prelude::*,
 };
 use std::collections::HashMap;
 
@@ -17,7 +16,9 @@ use std::collections::HashMap;
 #[derive(Error, Debug, Clone)]
 pub enum Reject {
     /// Transaction fee lower than config
-    #[error("The min fee rate is {0}, requiring a transaction fee of at least {1} shannons, but the fee provided is only {2}")]
+    #[error(
+        "The min fee rate is {0}, requiring a transaction fee of at least {1} shannons, but the fee provided is only {2}"
+    )]
     LowFeeRate(FeeRate, u64, u64),
 
     /// Transaction exceeded maximum ancestors count limit
diff --git a/util/types/src/core/views.rs b/util/types/src/core/views.rs
index 979b06c33b..795cfac0b8 100644
--- a/util/types/src/core/views.rs
+++ b/util/types/src/core/views.rs
@@ -6,12 +6,12 @@ use ckb_hash::new_blake2b;
 use ckb_occupied_capacity::Result as CapacityResult;
 
 use crate::{
+    U256,
     bytes::Bytes,
     core::{BlockNumber, Capacity, EpochNumberWithFraction, Version},
     packed,
     prelude::*,
     utilities::merkle_root,
-    U256,
 };
 
 /*
diff --git a/util/types/src/extension.rs b/util/types/src/extension.rs
index cd4f27392e..650b6443eb 100644
--- a/util/types/src/extension.rs
+++ b/util/types/src/extension.rs
@@ -1,11 +1,11 @@
 use std::collections::HashSet;
 
 use crate::{
+    U256,
     core::{self},
     packed,
     prelude::*,
     utilities::{compact_to_difficulty, merkle_root},
-    U256,
 };
 
 impl Difficulty for packed::RawHeader {
diff --git a/util/types/src/lib.rs b/util/types/src/lib.rs
index 4fcbd9fe2a..963c2a2ed4 100644
--- a/util/types/src/lib.rs
+++ b/util/types/src/lib.rs
@@ -6,10 +6,10 @@ pub mod prelude;
 
 pub use block_number_and_hash::BlockNumberAndHash;
 pub use bytes;
-pub use ckb_fixed_hash::{h160, h256, H160, H256};
+pub use ckb_fixed_hash::{H160, H256, h160, h256};
 pub use ckb_gen_types::packed;
 pub use molecule::{self, error};
-pub use numext_fixed_uint::{u256, U128, U256};
+pub use numext_fixed_uint::{U128, U256, u256};
 pub mod core;
 pub mod global;
 
diff --git a/util/types/src/prelude.rs b/util/types/src/prelude.rs
index f9c2a228b6..49408e97e4 100644
--- a/util/types/src/prelude.rs
+++ b/util/types/src/prelude.rs
@@ -5,11 +5,12 @@
 
 pub use crate::utilities::merkle_mountain_range::ProverMessageBuilder;
 use crate::{
+    U256,
     core::{
         BlockBuilder, BlockView, ExtraHashView, HeaderBuilder, HeaderView, TransactionBuilder,
         TransactionView, UncleBlockView,
     },
-    packed, U256,
+    packed,
 };
 
 pub use ckb_gen_types::prelude::*;
diff --git a/util/types/src/utilities/block_filter.rs b/util/types/src/utilities/block_filter.rs
index ab433a8f6f..cbde2caedf 100644
--- a/util/types/src/utilities/block_filter.rs
+++ b/util/types/src/utilities/block_filter.rs
@@ -1,7 +1,7 @@
 use std::io::{Cursor, Write};
 
 use ckb_hash::blake2b_256;
-use golomb_coded_set::{GCSFilterWriter, SipHasher24Builder, M, P};
+use golomb_coded_set::{GCSFilterWriter, M, P, SipHasher24Builder};
 
 use crate::{core::TransactionView, packed, prelude::*};
 
diff --git a/util/types/src/utilities/difficulty.rs b/util/types/src/utilities/difficulty.rs
index 7eda1a8119..313d64dfb4 100644
--- a/util/types/src/utilities/difficulty.rs
+++ b/util/types/src/utilities/difficulty.rs
@@ -1,5 +1,5 @@
 use numext_fixed_uint::prelude::UintConvert;
-use numext_fixed_uint::{u512, U256, U512};
+use numext_fixed_uint::{U256, U512, u512};
 
 /// The minimal difficulty that can be represented in the compact format.
 pub const DIFF_TWO: u32 = 0x2080_0000;
diff --git a/util/types/src/utilities/merkle_mountain_range.rs b/util/types/src/utilities/merkle_mountain_range.rs
index 2f8a9d71b4..644f3c0e07 100644
--- a/util/types/src/utilities/merkle_mountain_range.rs
+++ b/util/types/src/utilities/merkle_mountain_range.rs
@@ -5,15 +5,14 @@
 //! - [CKB RFC 0044](https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0044-ckb-light-client/0044-ckb-light-client.md)
 
 use ckb_hash::new_blake2b;
-use ckb_merkle_mountain_range::{Error as MMRError, Merge, MerkleProof, Result as MMRResult, MMR};
+use ckb_merkle_mountain_range::{Error as MMRError, MMR, Merge, MerkleProof, Result as MMRResult};
 
 use crate::{
-    core,
+    U256, core,
     core::{BlockNumber, EpochNumber, EpochNumberWithFraction, ExtraHashView, HeaderView},
     packed,
     prelude::*,
     utilities::compact_to_difficulty,
-    U256,
 };
 
 /// A struct to implement MMR `Merge` trait
diff --git a/util/types/src/utilities/merkle_tree.rs b/util/types/src/utilities/merkle_tree.rs
index 75c2e152f2..2cac1a78f6 100644
--- a/util/types/src/utilities/merkle_tree.rs
+++ b/util/types/src/utilities/merkle_tree.rs
@@ -1,5 +1,5 @@
 use ckb_hash::new_blake2b;
-use merkle_cbt::{merkle_tree::Merge, MerkleProof as ExMerkleProof, CBMT as ExCBMT};
+use merkle_cbt::{CBMT as ExCBMT, MerkleProof as ExMerkleProof, merkle_tree::Merge};
 
 use crate::{packed::Byte32, prelude::*};
 
diff --git a/util/types/src/utilities/mod.rs b/util/types/src/utilities/mod.rs
index 086b11897c..9abdfc4c34 100644
--- a/util/types/src/utilities/mod.rs
+++ b/util/types/src/utilities/mod.rs
@@ -7,8 +7,8 @@ mod merkle_tree;
 #[cfg(test)]
 mod tests;
 
-pub use block_filter::{build_filter_data, calc_filter_hash, FilterDataProvider};
+pub use block_filter::{FilterDataProvider, build_filter_data, calc_filter_hash};
 pub use difficulty::{
-    compact_to_difficulty, compact_to_target, difficulty_to_compact, target_to_compact, DIFF_TWO,
+    DIFF_TWO, compact_to_difficulty, compact_to_target, difficulty_to_compact, target_to_compact,
 };
-pub use merkle_tree::{merkle_root, MergeByte32, MerkleProof, CBMT};
+pub use merkle_tree::{CBMT, MergeByte32, MerkleProof, merkle_root};
diff --git a/util/types/src/utilities/tests/difficulty.rs b/util/types/src/utilities/tests/difficulty.rs
index e1b26251cf..2017ffe31d 100644
--- a/util/types/src/utilities/tests/difficulty.rs
+++ b/util/types/src/utilities/tests/difficulty.rs
@@ -1,6 +1,6 @@
 // #[allow(clippy::unreadable_literal, clippy::cognitive_complexity)]
 
-use numext_fixed_uint::{u256, U256};
+use numext_fixed_uint::{U256, u256};
 use proptest::prelude::*;
 
 use crate::utilities::{
diff --git a/verification/contextual/src/contextual_block_verifier.rs b/verification/contextual/src/contextual_block_verifier.rs
index 74bd483a47..350366e844 100644
--- a/verification/contextual/src/contextual_block_verifier.rs
+++ b/verification/contextual/src/contextual_block_verifier.rs
@@ -10,13 +10,13 @@ use ckb_error::{Error, InternalErrorKind};
 use ckb_logger::error_target;
 use ckb_merkle_mountain_range::MMRStore;
 use ckb_reward_calculator::RewardCalculator;
-use ckb_store::{data_loader_wrapper::AsDataLoader, ChainStore};
+use ckb_store::{ChainStore, data_loader_wrapper::AsDataLoader};
 use ckb_traits::HeaderProvider;
 use ckb_types::{
     core::error::OutPointError,
     core::{
-        cell::{HeaderChecker, ResolvedTransaction},
         BlockReward, BlockView, Capacity, Cycle, EpochExt, HeaderView, TransactionView,
+        cell::{HeaderChecker, ResolvedTransaction},
     },
     packed::{Byte32, CellOutput, HeaderDigest, Script},
     prelude::*,
@@ -34,7 +34,7 @@ use ckb_verification_traits::Switch;
 use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator};
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
-use tokio::sync::{oneshot, RwLock};
+use tokio::sync::{RwLock, oneshot};
 
 /// Context for context-dependent block verification
 pub struct VerifyContext<CS> {
diff --git a/verification/contextual/src/tests/contextual_block_verifier.rs b/verification/contextual/src/tests/contextual_block_verifier.rs
index fc6c4182d4..5e6c782920 100644
--- a/verification/contextual/src/tests/contextual_block_verifier.rs
+++ b/verification/contextual/src/tests/contextual_block_verifier.rs
@@ -1,6 +1,6 @@
 use super::super::contextual_block_verifier::{EpochVerifier, TwoPhaseCommitVerifier};
 use crate::contextual_block_verifier::{RewardVerifier, VerifyContext};
-use ckb_chain::{start_chain_services, ChainController};
+use ckb_chain::{ChainController, start_chain_services};
 use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_error::assert_error_eq;
 use ckb_shared::{Shared, SharedBuilder};
@@ -9,9 +9,9 @@ use ckb_test_chain_utils::always_success_cell;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes, cell::ResolvedTransaction, BlockBuilder, BlockNumber, BlockView, Capacity,
-        EpochExt, EpochNumberWithFraction, HeaderBuilder, HeaderView, TransactionBuilder,
-        TransactionView, UncleBlockView,
+        BlockBuilder, BlockNumber, BlockView, Capacity, EpochExt, EpochNumberWithFraction,
+        HeaderBuilder, HeaderView, TransactionBuilder, TransactionView, UncleBlockView,
+        capacity_bytes, cell::ResolvedTransaction,
     },
     packed::{Byte32, CellDep, CellInput, CellOutputBuilder, OutPoint, ProposalShortId, Script},
     prelude::*,
diff --git a/verification/contextual/src/tests/uncle_verifier.rs b/verification/contextual/src/tests/uncle_verifier.rs
index 0928abdee9..1659c7c51b 100644
--- a/verification/contextual/src/tests/uncle_verifier.rs
+++ b/verification/contextual/src/tests/uncle_verifier.rs
@@ -2,7 +2,7 @@
 
 use crate::contextual_block_verifier::{UncleVerifierContext, VerifyContext};
 use crate::uncles_verifier::UnclesVerifier;
-use ckb_chain::{start_chain_services, ChainController};
+use ckb_chain::{ChainController, start_chain_services};
 use ckb_chain_spec::consensus::Consensus;
 use ckb_error::assert_error_eq;
 use ckb_shared::{Shared, SharedBuilder};
diff --git a/verification/src/block_verifier.rs b/verification/src/block_verifier.rs
index 488afa57a8..524bcbec45 100644
--- a/verification/src/block_verifier.rs
+++ b/verification/src/block_verifier.rs
@@ -1,5 +1,5 @@
 use crate::{
-    transaction_verifier::NonContextualTransactionVerifier, BlockErrorKind, CellbaseError,
+    BlockErrorKind, CellbaseError, transaction_verifier::NonContextualTransactionVerifier,
 };
 use ckb_chain_spec::consensus::Consensus;
 use ckb_error::Error;
diff --git a/verification/src/convert.rs b/verification/src/convert.rs
index 61a8696327..8575aeae45 100644
--- a/verification/src/convert.rs
+++ b/verification/src/convert.rs
@@ -4,7 +4,7 @@ use crate::error::{
     PowError, TimestampError, UnclesError, UnknownParentError,
 };
 use ckb_error::{
-    impl_error_conversion_with_adaptor, impl_error_conversion_with_kind, Error, ErrorKind,
+    Error, ErrorKind, impl_error_conversion_with_adaptor, impl_error_conversion_with_kind,
 };
 
 impl_error_conversion_with_kind!(HeaderError, ErrorKind::Header, Error);
diff --git a/verification/src/error.rs b/verification/src/error.rs
index d019251002..e6e4ffd805 100644
--- a/verification/src/error.rs
+++ b/verification/src/error.rs
@@ -1,10 +1,10 @@
-use ckb_error::{def_error_base_on_kind, prelude::*, Error};
+use ckb_error::{Error, def_error_base_on_kind, prelude::*};
 use ckb_types::{core::Version, packed::Byte32};
 use derive_more::Display;
 
 pub use ckb_types::core::{
-    error::{TransactionError, TransactionErrorSource},
     EpochNumberWithFraction,
+    error::{TransactionError, TransactionErrorSource},
 };
 
 /// A list specifying categories of ckb header error.
@@ -275,7 +275,9 @@ pub struct InvalidParentError {
 #[derive(Error, Debug, PartialEq, Eq, Clone)]
 pub enum PowError {
     /// Error occurs during PoW verification.
-    #[error("InvalidNonce: please set logger.filter to \"info,ckb-pow=debug\" for detailed PoW verification information")]
+    #[error(
+        "InvalidNonce: please set logger.filter to \"info,ckb-pow=debug\" for detailed PoW verification information"
+    )]
     InvalidNonce,
 }
 
diff --git a/verification/src/genesis_verifier.rs b/verification/src/genesis_verifier.rs
index f36ddddacb..0319358320 100644
--- a/verification/src/genesis_verifier.rs
+++ b/verification/src/genesis_verifier.rs
@@ -1,6 +1,6 @@
 use crate::{
-    error::CellbaseError, BlockErrorKind, BlockVerifier, EpochError, NumberError, UnclesError,
-    UnknownParentError,
+    BlockErrorKind, BlockVerifier, EpochError, NumberError, UnclesError, UnknownParentError,
+    error::CellbaseError,
 };
 use ckb_chain_spec::{calculate_block_reward, consensus::Consensus};
 use ckb_dao_utils::genesis_dao_data_with_satoshi_gift;
diff --git a/verification/src/header_verifier.rs b/verification/src/header_verifier.rs
index 7b9d42c4ad..ac9e78a86a 100644
--- a/verification/src/header_verifier.rs
+++ b/verification/src/header_verifier.rs
@@ -1,6 +1,6 @@
 use crate::{
-    BlockVersionError, EpochError, NumberError, PowError, TimestampError, UnknownParentError,
-    ALLOWED_FUTURE_BLOCKTIME,
+    ALLOWED_FUTURE_BLOCKTIME, BlockVersionError, EpochError, NumberError, PowError, TimestampError,
+    UnknownParentError,
 };
 use ckb_chain_spec::consensus::Consensus;
 use ckb_error::Error;
diff --git a/verification/src/tests/block_verifier.rs b/verification/src/tests/block_verifier.rs
index bdcdffa223..1c47d3e13b 100644
--- a/verification/src/tests/block_verifier.rs
+++ b/verification/src/tests/block_verifier.rs
@@ -7,8 +7,8 @@ use ckb_error::assert_error_eq;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes, BlockBuilder, BlockNumber, Capacity, HeaderBuilder, TransactionBuilder,
-        TransactionView,
+        BlockBuilder, BlockNumber, Capacity, HeaderBuilder, TransactionBuilder, TransactionView,
+        capacity_bytes,
     },
     h256,
     packed::{Byte32, CellInput, CellOutputBuilder, OutPoint, ProposalShortId, Script},
diff --git a/verification/src/tests/genesis_verifier.rs b/verification/src/tests/genesis_verifier.rs
index 716ef144c4..9b82e9a813 100644
--- a/verification/src/tests/genesis_verifier.rs
+++ b/verification/src/tests/genesis_verifier.rs
@@ -1,4 +1,4 @@
-use crate::{genesis_verifier::GenesisVerifier, NumberError, UnknownParentError};
+use crate::{NumberError, UnknownParentError, genesis_verifier::GenesisVerifier};
 use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_error::assert_error_eq;
 use ckb_types::{core::EpochNumberWithFraction, prelude::*};
@@ -54,7 +54,7 @@ pub fn test_default_genesis() {
 #[test]
 pub fn test_chain_specs() {
     use ckb_chain_spec::ChainSpec;
-    use ckb_resource::{Resource, AVAILABLE_SPECS};
+    use ckb_resource::{AVAILABLE_SPECS, Resource};
     fn load_spec_by_name(name: &str) -> ChainSpec {
         let res = Resource::bundled(format!("specs/{name}.toml"));
         ChainSpec::load_from(&res).expect("load spec by name")
diff --git a/verification/src/tests/header_verifier.rs b/verification/src/tests/header_verifier.rs
index 8fe6abbbaa..3ee45127f8 100644
--- a/verification/src/tests/header_verifier.rs
+++ b/verification/src/tests/header_verifier.rs
@@ -2,17 +2,17 @@ use crate::header_verifier::{
     EpochVerifier, NumberVerifier, PowVerifier, TimestampVerifier, VersionVerifier,
 };
 use crate::{
-    BlockVersionError, EpochError, NumberError, PowError, TimestampError, ALLOWED_FUTURE_BLOCKTIME,
+    ALLOWED_FUTURE_BLOCKTIME, BlockVersionError, EpochError, NumberError, PowError, TimestampError,
 };
 use ckb_chain_spec::consensus::ConsensusBuilder;
 use ckb_error::assert_error_eq;
 use ckb_pow::PowEngine;
 use ckb_systemtime::unix_time_as_millis;
-use ckb_test_chain_utils::{MockMedianTime, MOCK_MEDIAN_TIME_COUNT};
+use ckb_test_chain_utils::{MOCK_MEDIAN_TIME_COUNT, MockMedianTime};
 use ckb_types::{
     core::{
-        hardfork::{HardForks, CKB2021, CKB2023},
         EpochNumberWithFraction, HeaderBuilder,
+        hardfork::{CKB2021, CKB2023, HardForks},
     },
     packed::Header,
     prelude::*,
diff --git a/verification/src/tests/transaction_verifier.rs b/verification/src/tests/transaction_verifier.rs
index 16f05fe1fe..7a02c2711f 100644
--- a/verification/src/tests/transaction_verifier.rs
+++ b/verification/src/tests/transaction_verifier.rs
@@ -5,22 +5,20 @@ use super::super::transaction_verifier::{
 use crate::error::TransactionErrorSource;
 use crate::{TransactionError, TxVerifyEnv};
 use ckb_chain_spec::{
-    build_genesis_type_id_script,
+    OUTPUT_INDEX_DAO, build_genesis_type_id_script,
     consensus::{Consensus, ConsensusBuilder},
-    OUTPUT_INDEX_DAO,
 };
-use ckb_error::{assert_error_eq, Error};
-use ckb_test_chain_utils::{MockMedianTime, MOCK_MEDIAN_TIME_COUNT};
+use ckb_error::{Error, assert_error_eq};
+use ckb_test_chain_utils::{MOCK_MEDIAN_TIME_COUNT, MockMedianTime};
 use ckb_traits::CellDataProvider;
 use ckb_types::{
     bytes::Bytes,
     constants::TX_VERSION,
     core::{
-        capacity_bytes,
+        BlockNumber, Capacity, EpochNumber, EpochNumberWithFraction, HeaderView, ScriptHashType,
+        TransactionBuilder, TransactionInfo, TransactionView, capacity_bytes,
         cell::{CellMetaBuilder, ResolvedTransaction},
         hardfork::HardForks,
-        BlockNumber, Capacity, EpochNumber, EpochNumberWithFraction, HeaderView, ScriptHashType,
-        TransactionBuilder, TransactionInfo, TransactionView,
     },
     h256,
     packed::{Byte32, CellDep, CellInput, CellOutput, OutPoint, Script},
@@ -94,13 +92,15 @@ pub fn test_capacity_outofbound() {
     let rtx = Arc::new(ResolvedTransaction {
         transaction,
         resolved_cell_deps: Vec::new(),
-        resolved_inputs: vec![CellMetaBuilder::from_cell_output(
-            CellOutput::new_builder()
-                .capacity(capacity_bytes!(50).pack())
-                .build(),
-            Bytes::new(),
-        )
-        .build()],
+        resolved_inputs: vec![
+            CellMetaBuilder::from_cell_output(
+                CellOutput::new_builder()
+                    .capacity(capacity_bytes!(50).pack())
+                    .build(),
+                Bytes::new(),
+            )
+            .build(),
+        ],
         resolved_dep_groups: vec![],
     });
     let dao_type_hash = build_genesis_type_id_script(OUTPUT_INDEX_DAO).calc_script_hash();
@@ -155,9 +155,11 @@ pub fn test_inputs_cellbase_maturity() {
         transaction,
         resolved_cell_deps: Vec::new(),
         resolved_dep_groups: Vec::new(),
-        resolved_inputs: vec![CellMetaBuilder::from_cell_output(output, Bytes::new())
-            .transaction_info(mock_transaction_info(30, base_epoch, 0))
-            .build()],
+        resolved_inputs: vec![
+            CellMetaBuilder::from_cell_output(output, Bytes::new())
+                .transaction_info(mock_transaction_info(30, base_epoch, 0))
+                .build(),
+        ],
     });
 
     let mut current_epoch = EpochNumberWithFraction::new(0, 0, 10);
@@ -206,9 +208,11 @@ fn test_ignore_genesis_cellbase_maturity() {
         transaction,
         resolved_cell_deps: Vec::new(),
         resolved_dep_groups: Vec::new(),
-        resolved_inputs: vec![CellMetaBuilder::from_cell_output(output, Bytes::new())
-            .transaction_info(mock_transaction_info(0, base_epoch, 0))
-            .build()],
+        resolved_inputs: vec![
+            CellMetaBuilder::from_cell_output(output, Bytes::new())
+                .transaction_info(mock_transaction_info(0, base_epoch, 0))
+                .build(),
+        ],
     });
 
     let mut current_epoch = EpochNumberWithFraction::new(0, 0, 10);
@@ -442,14 +446,16 @@ fn create_resolve_tx_with_transaction_info(
     Arc::new(ResolvedTransaction {
         transaction: tx.clone(),
         resolved_cell_deps: Vec::new(),
-        resolved_inputs: vec![CellMetaBuilder::from_cell_output(
-            CellOutput::new_builder()
-                .capacity(capacity_bytes!(50).pack())
-                .build(),
-            Bytes::new(),
-        )
-        .transaction_info(transaction_info)
-        .build()],
+        resolved_inputs: vec![
+            CellMetaBuilder::from_cell_output(
+                CellOutput::new_builder()
+                    .capacity(capacity_bytes!(50).pack())
+                    .build(),
+                Bytes::new(),
+            )
+            .transaction_info(transaction_info)
+            .build(),
+        ],
         resolved_dep_groups: vec![],
     })
 }
diff --git a/verification/src/transaction_verifier.rs b/verification/src/transaction_verifier.rs
index 0b90b897a9..9def21e38c 100644
--- a/verification/src/transaction_verifier.rs
+++ b/verification/src/transaction_verifier.rs
@@ -13,8 +13,8 @@ use ckb_traits::{
 };
 use ckb_types::{
     core::{
-        cell::{CellMeta, ResolvedTransaction},
         Capacity, Cycle, EpochNumberWithFraction, ScriptHashType, TransactionView, Version,
+        cell::{CellMeta, ResolvedTransaction},
     },
     packed::{Byte32, CellOutput},
     prelude::*,