change some safe as_u64 to low_u64 & cargo fmt

common/apm-derive/src/rpc_expand.rs

@@ -13,33 +13,29 @@ pub fn expand_rpc_metrics(attr: TokenStream, func: TokenStream) -> TokenStream {
     let func_block = &func.block;
     let func_output = &func_sig.output;
     let func_return = PinBoxFutRet::parse(func_output);
-    let func_ret_ty =
-        match func_output {
-            ReturnType::Default => quote! { () },
-            ReturnType::Type(_, ty) => quote! { #ty },
-        };
+    let func_ret_ty = match func_output {
+        ReturnType::Default => quote! { () },
+        ReturnType::Type(_, ty) => quote! { #ty },
+    };
     let ret_ty = func_return.return_type();
     let args = func_sig
         .inputs
         .iter()
         .filter_map(|arg| match arg {
             syn::FnArg::Receiver(_) => None,
-            syn::FnArg::Typed(inner) => {
-                match &*inner.pat {
-                    syn::Pat::Ident(pat) => Some(pat.ident.clone()),
-                    _ => None,
-                }
-            }
+            syn::FnArg::Typed(inner) => match &*inner.pat {
+                syn::Pat::Ident(pat) => Some(pat.ident.clone()),
+                _ => None,
+            },
         })
         .collect::<Vec<_>>();
 
     let fn_name = func_ident.to_string();
-    let mut debug =
-        if args.is_empty() {
-            "call rpc {}".to_string()
-        } else {
-            "call rpc {} with args,".to_string()
-        };
+    let mut debug = if args.is_empty() {
+        "call rpc {}".to_string()
+    } else {
+        "call rpc {} with args,".to_string()
+    };
     for (index, name) in args.iter().enumerate() {
         if index != 0 {
             debug.push(',')

common/apm-derive/src/trace_expand.rs

@@ -25,11 +25,10 @@ pub fn expand_trace_span(attr: TokenStream, func: TokenStream) -> TokenStream {
     let func_block = &func.block;
     let func_output = &func_sig.output;
     let func_return = PinBoxFutRet::parse(func_output);
-    let func_ret_ty =
-        match func_output {
-            ReturnType::Default => quote! { () },
-            ReturnType::Type(_, ty) => quote! { #ty },
-        };
+    let func_ret_ty = match func_output {
+        ReturnType::Default => quote! { () },
+        ReturnType::Type(_, ty) => quote! { #ty },
+    };
     let trace_info = TraceAttrs::new(&attr);
     let trace_name = trace_info.trace_name(&func_sig.ident);
     let span_tag_stmts = trace_info.span_tags();

common/apm/src/metrics/api.rs

@@ -62,21 +62,19 @@ make_auto_flush_static_metric! {
 }
 
 lazy_static! {
-    pub static ref API_REQUEST_RESULT_COUNTER_VEC: CounterVec =
-        register_counter_vec!(
-            "axon_api_request_result_total",
-            "Total number of request result",
-            &["type", "result"]
-        )
-        .expect("request result total");
-    pub static ref API_REQUEST_TIME_HISTOGRAM_VEC: HistogramVec =
-        register_histogram_vec!(
-            "axon_api_request_time_cost_seconds",
-            "Request process time cost",
-            &["type"],
-            exponential_buckets(0.001, 2.0, 20).expect("api req time expontial")
-        )
-        .expect("request time cost");
+    pub static ref API_REQUEST_RESULT_COUNTER_VEC: CounterVec = register_counter_vec!(
+        "axon_api_request_result_total",
+        "Total number of request result",
+        &["type", "result"]
+    )
+    .expect("request result total");
+    pub static ref API_REQUEST_TIME_HISTOGRAM_VEC: HistogramVec = register_histogram_vec!(
+        "axon_api_request_time_cost_seconds",
+        "Request process time cost",
+        &["type"],
+        exponential_buckets(0.001, 2.0, 20).expect("api req time expontial")
+    )
+    .expect("request time cost");
 }
 
 lazy_static! {

common/apm/src/metrics/consensus.rs

@@ -88,12 +88,11 @@ lazy_static! {
         register_int_gauge!("axon_consensus_height", "Height of axon").unwrap();
     pub static ref ENGINE_EXECUTING_BLOCK_GAUGE: IntGauge =
         register_int_gauge!("axon_executing_block_count", "The executing blocks").unwrap();
-    pub static ref ENGINE_COMMITTED_TX_COUNTER: IntCounter =
-        register_int_counter!(
-            "axon_consensus_committed_tx_total",
-            "The committed transactions"
-        )
-        .unwrap();
+    pub static ref ENGINE_COMMITTED_TX_COUNTER: IntCounter = register_int_counter!(
+        "axon_consensus_committed_tx_total",
+        "The committed transactions"
+    )
+    .unwrap();
     pub static ref ENGINE_ORDER_TX_GAUGE: IntGauge =
         register_int_gauge!("axon_proposal_order_tx_len", "The ordered transactions len").unwrap();
     pub static ref ENGINE_SYNC_TX_GAUGE: IntGauge =

common/apm/src/metrics/mempool.rs

@@ -56,14 +56,13 @@ lazy_static! {
         exponential_buckets(0.05, 2.0, 10).expect("mempool time expontial")
     )
     .expect("mempool time cost");
-    pub static ref MEMPOOL_PACKAGE_SIZE_VEC: HistogramVec =
-        register_histogram_vec!(
-            "axon_mempool_package_size_vec",
-            "Package size",
-            &["type"],
-            exponential_buckets(0.05, 2.0, 10).expect("mempool package size exponential")
-        )
-        .expect("mempool package size");
+    pub static ref MEMPOOL_PACKAGE_SIZE_VEC: HistogramVec = register_histogram_vec!(
+        "axon_mempool_package_size_vec",
+        "Package size",
+        &["type"],
+        exponential_buckets(0.05, 2.0, 10).expect("mempool package size exponential")
+    )
+    .expect("mempool package size");
     pub static ref MEMPOOL_CURRENT_SIZE_VEC: HistogramVec = register_histogram_vec!(
         "axon_mempool_current_size_vec",
         "Current size",

common/config-parser/src/types/config.rs

@@ -107,12 +107,11 @@ impl TypedValueParser for ConfigValueParser {
             .parse_ref(cmd, arg, value)
             .map(PathBuf::from)?;
         let dir_path = file_path.parent().ok_or_else(|| {
-            let err =
-                {
-                    let kind = io::ErrorKind::Other;
-                    let msg = format!("no parent directory of {}", file_path.display());
-                    io::Error::new(kind, msg)
-                };
+            let err = {
+                let kind = io::ErrorKind::Other;
+                let msg = format!("no parent directory of {}", file_path.display());
+                io::Error::new(kind, msg)
+            };
             let kind = clap::error::ErrorKind::InvalidValue;
             clap::Error::raw(kind, err)
         })?;

common/config-parser/src/types/mod.rs

@@ -39,11 +39,10 @@ where
             .map(PathBuf::from)?;
         parse_file(&file_path, true).map_err(|err| {
             let kind = clap::error::ErrorKind::InvalidValue;
-            let msg =
-                format!(
-                    "failed to parse JSON file {} since {err}",
-                    file_path.display()
-                );
+            let msg = format!(
+                "failed to parse JSON file {} since {err}",
+                file_path.display()
+            );
             clap::Error::raw(kind, msg)
         })
     }

common/config-parser/src/types/spec.rs

@@ -93,11 +93,10 @@ impl TypedValueParser for ChainSpecValueParser {
             .map(PathBuf::from)?;
         parse_file(&file_path, false).map_err(|err| {
             let kind = clap::error::ErrorKind::InvalidValue;
-            let msg =
-                format!(
-                    "failed to parse chain spec file {} since {err}",
-                    file_path.display()
-                );
+            let msg = format!(
+                "failed to parse chain spec file {} since {err}",
+                file_path.display()
+            );
             clap::Error::raw(kind, msg)
         })
     }

core/api/src/adapter.rs

@@ -202,15 +202,14 @@ where
             .map(|p| U256::from(p.low_u64()))
             .unwrap_or_else(U256::one);
 
-        let backend =
-            AxonExecutorReadOnlyAdapter::from_root(
-                state_root,
-                Arc::clone(&self.trie_db),
-                Arc::clone(&self.storage),
-                exec_ctx,
-            )?;
+        let backend = AxonExecutorReadOnlyAdapter::from_root(
+            state_root,
+            Arc::clone(&self.trie_db),
+            Arc::clone(&self.storage),
+            exec_ctx,
+        )?;
         let gas_limit = gas_limit
-            .map(|gas| gas.as_u64())
+            .map(|gas| gas.low_u64())
             .unwrap_or(MAX_BLOCK_GAS_LIMIT);
 
         Ok(AxonExecutor.call(&backend, gas_limit, from, to, value, data))
@@ -280,9 +279,9 @@ where
                     .get(hash.as_bytes())?
                     .map(|v| H256::from_slice(&v))
                     .ok_or_else(|| {
-                        Into::<ProtocolError>::into(
-                            APIError::Adapter("Can't find this position".to_string())
-                        )
+                        Into::<ProtocolError>::into(APIError::Adapter(
+                            "Can't find this position".to_string(),
+                        ))
                     })?,
                 proof: storage_mpt_tree
                     .get_proof(hash.as_bytes())?

core/api/src/jsonrpc/impl/axon.rs

@@ -30,7 +30,7 @@ impl<Adapter: APIAdapter + 'static> AxonRpcServer for AxonRpcImpl<Adapter> {
             BlockId::Hash(hash) => self.adapter.get_block_by_hash(Context::new(), hash).await,
             BlockId::Num(num) => {
                 self.adapter
-                    .get_block_by_number(Context::new(), Some(num.as_u64()))
+                    .get_block_by_number(Context::new(), Some(num.low_u64()))
                     .await
             }
             BlockId::Latest => self.adapter.get_block_by_number(Context::new(), None).await,
@@ -52,7 +52,7 @@ impl<Adapter: APIAdapter + 'static> AxonRpcServer for AxonRpcImpl<Adapter> {
     async fn get_metadata_by_number(&self, block_number: U256) -> RpcResult<Metadata> {
         let ret = self
             .adapter
-            .get_metadata_by_number(Context::new(), Some(block_number.as_u64()))
+            .get_metadata_by_number(Context::new(), Some(block_number.low_u64()))
             .await
             .map_err(|e| RpcError::Internal(e.to_string()))?;
 
@@ -278,33 +278,32 @@ mod test {
         });
         assert_eq!(vd31, H256::zero());
 
-        let v4 =
-            vec![
-                HardforkInfoInner {
-                    block_number: 0,
-                    flags:        {
-                        let mut a = [0; 32];
-                        a[0] = 0b10;
-                        H256::from(a)
-                    },
+        let v4 = vec![
+            HardforkInfoInner {
+                block_number: 0,
+                flags:        {
+                    let mut a = [0; 32];
+                    a[0] = 0b10;
+                    H256::from(a)
                 },
-                HardforkInfoInner {
-                    block_number: 5,
-                    flags:        {
-                        let mut a = [0; 32];
-                        a[0] = 0b11;
-                        H256::from(a)
-                    },
+            },
+            HardforkInfoInner {
+                block_number: 5,
+                flags:        {
+                    let mut a = [0; 32];
+                    a[0] = 0b11;
+                    H256::from(a)
                 },
-                HardforkInfoInner {
-                    block_number: 10,
-                    flags:        {
-                        let mut a = [0; 32];
-                        a[0] = 0b111;
-                        H256::from(a)
-                    },
+            },
+            HardforkInfoInner {
+                block_number: 10,
+                flags:        {
+                    let mut a = [0; 32];
+                    a[0] = 0b111;
+                    H256::from(a)
                 },
-            ];
+            },
+        ];
 
         let (ve4, vd4) = enabled_and_determined(&v4, 0);
 

core/api/src/jsonrpc/impl/filter.rs

@@ -204,7 +204,7 @@ where
 
                 match from {
                     BlockId::Num(n) => {
-                        if n.as_u64() < header.number {
+                        if n.low_u64() < header.number {
                             filter.from_block = Some(BlockId::Num(U64::from(header.number + 1)));
                         }
                     }
@@ -302,7 +302,7 @@ where
         let (start, end) = {
             let convert = |id: &BlockId| -> BlockNumber {
                 match id {
-                    BlockId::Num(n) => n.as_u64(),
+                    BlockId::Num(n) => n.low_u64(),
                     BlockId::Earliest => 0,
                     _ => latest_number,
                 }