chore: make formatter happy

Author: syjn99

beacon_node/http_api/src/lib.rs

@@ -1141,23 +1141,32 @@ pub fn serve<T: BeaconChainTypes>(
                             |state, execution_optimistic, finalized| {
                                 if !state.fork_name_unchecked().electra_enabled() {
                                     return Err(warp_utils::reject::pre_electra_not_supported(
-                                        format!("state at epoch {} is not activated for Electra", state.current_epoch())
+                                        format!(
+                                            "state at epoch {} is not activated for Electra",
+                                            state.current_epoch()
+                                        ),
                                     ));
                                 }
 
                                 let Ok(deposits) = state.pending_deposits() else {
-                                    return Err(warp_utils::reject::custom_bad_request("Pending deposits not found".to_string()));
+                                    return Err(warp_utils::reject::custom_bad_request(
+                                        "Pending deposits not found".to_string(),
+                                    ));
                                 };
 
-                                Ok((deposits.iter().cloned().collect::<Vec<_>>(), execution_optimistic, finalized))
-                            }
+                                Ok((
+                                    deposits.iter().cloned().collect::<Vec<_>>(),
+                                    execution_optimistic,
+                                    finalized,
+                                ))
+                            },
                         )?;
 
-                        Ok(api_types::ExecutionOptimisticFinalizedResponse {
-                            data,
-                            execution_optimistic: Some(execution_optimistic),
-                            finalized: Some(finalized),
-                        })
+                    Ok(api_types::ExecutionOptimisticFinalizedResponse {
+                        data,
+                        execution_optimistic: Some(execution_optimistic),
+                        finalized: Some(finalized),
+                    })
                 })
             },
         );
@@ -1178,28 +1187,36 @@ pub fn serve<T: BeaconChainTypes>(
                             |state, execution_optimistic, finalized| {
                                 if !state.fork_name_unchecked().electra_enabled() {
                                     return Err(warp_utils::reject::pre_electra_not_supported(
-                                        format!("state at epoch {} is not activated for Electra", state.current_epoch())
+                                        format!(
+                                            "state at epoch {} is not activated for Electra",
+                                            state.current_epoch()
+                                        ),
                                     ));
                                 }
 
                                 let Ok(withdrawals) = state.pending_partial_withdrawals() else {
-                                    return Err(warp_utils::reject::custom_bad_request("Pending withdrawals not found".to_string()));
+                                    return Err(warp_utils::reject::custom_bad_request(
+                                        "Pending withdrawals not found".to_string(),
+                                    ));
                                 };
 
-                                Ok((withdrawals.iter().cloned().collect::<Vec<_>>(), execution_optimistic, finalized))
-                            }
+                                Ok((
+                                    withdrawals.iter().cloned().collect::<Vec<_>>(),
+                                    execution_optimistic,
+                                    finalized,
+                                ))
+                            },
                         )?;
 
-                        Ok(api_types::ExecutionOptimisticFinalizedResponse {
-                            data,
-                            execution_optimistic: Some(execution_optimistic),
-                            finalized: Some(finalized),
-                        })
+                    Ok(api_types::ExecutionOptimisticFinalizedResponse {
+                        data,
+                        execution_optimistic: Some(execution_optimistic),
+                        finalized: Some(finalized),
+                    })
                 })
             },
         );
 
-
     // GET beacon/headers
     //
     // Note: this endpoint only returns information about blocks in the canonical chain. Given that

beacon_node/http_api/tests/tests.rs

@@ -1211,9 +1211,7 @@ impl ApiTester {
             }
 
             let state = state_opt.as_mut().expect("result should be none");
-            let expected = state
-                .pending_deposits()
-                .unwrap();
+            let expected = state.pending_deposits().unwrap();
 
             assert_eq!(result.unwrap(), expected.to_vec());
         }
@@ -1240,9 +1238,7 @@ impl ApiTester {
             }
 
             let state = state_opt.as_mut().expect("result should be none");
-            let expected = state
-                .pending_partial_withdrawals()
-                .unwrap();
+            let expected = state.pending_partial_withdrawals().unwrap();
 
             assert_eq!(result.unwrap(), expected.to_vec());
         }
@@ -6390,7 +6386,6 @@ async fn beacon_get_state_info_electra() {
         .await;
 }
 
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn beacon_get_blocks() {
     ApiTester::new()

common/eth2/src/lib.rs

@@ -807,7 +807,8 @@ impl BeaconNodeHttpClient {
     pub async fn get_beacon_states_pending_partial_withdrawals(
         &self,
         state_id: StateId,
-    ) -> Result<Option<ExecutionOptimisticFinalizedResponse<Vec<PendingPartialWithdrawal>>>, Error> {
+    ) -> Result<Option<ExecutionOptimisticFinalizedResponse<Vec<PendingPartialWithdrawal>>>, Error>
+    {
         let mut path = self.eth_path(V1)?;
 
         path.path_segments_mut()