cargo fmt

blockchain/blocks/src/election_proof.rs

@@ -214,7 +214,10 @@ pub mod json {
             vrfproof,
             win_count,
         } = Deserialize::deserialize(deserializer)?;
-        Ok(ElectionProof { win_count, vrfproof })
+        Ok(ElectionProof {
+            win_count,
+            vrfproof,
+        })
     }
 
     pub mod opt {

blockchain/chain/src/store/chain_store.rs

@@ -895,7 +895,10 @@ pub fn genesis<DB>(db: &DB) -> Result<Option<BlockHeader>, Error>
 where
     DB: BlockStore,
 {
-    Ok(db.read(GENESIS_KEY)?.map(|bz| { BlockHeader::unmarshal_cbor(&bz) }).transpose()?)
+    Ok(db
+        .read(GENESIS_KEY)?
+        .map(|bz| BlockHeader::unmarshal_cbor(&bz))
+        .transpose()?)
 }
 
 /// Attempts to deserialize to unsigend message or signed message and then returns it at as a

blockchain/chain_sync/src/sync_worker/full_sync_test.rs

@@ -64,9 +64,7 @@ async fn space_race_full_sync() {
     let network = SyncNetworkContext::new(network_send, Arc::new(peer_manager), db);
 
     let provider_db = Arc::new(MemoryDB::default());
-    let cids: Vec<Cid> = load_car(provider_db.as_ref(), EXPORT_SR_40)
-        .await
-        .unwrap();
+    let cids: Vec<Cid> = load_car(provider_db.as_ref(), EXPORT_SR_40).await.unwrap();
     let prov_cs = ChainStore::new(provider_db);
     let target = prov_cs
         .tipset_from_keys(&TipsetKeys::new(cids))

blockchain/message_pool/src/msg_chain.rs

@@ -143,7 +143,7 @@ impl MsgChain {
 
     pub(crate) fn trim(&mut self, gas_limit: i64, base_fee: &BigInt) {
         let mut i = self.chain.len() as i64 - 1;
-        let prev = self.prev().map(|prev| { (prev.eff_perf, prev.gas_limit) });
+        let prev = self.prev().map(|prev| (prev.eff_perf, prev.gas_limit));
         let mut mc = self.curr_mut();
         while i >= 0 && (mc.gas_limit > gas_limit || (mc.gas_perf < 0.0)) {
             let gas_reward = get_gas_reward(&mc.msgs[i as usize], base_fee);
@@ -186,7 +186,7 @@ impl MsgChain {
     }
     #[allow(dead_code)]
     pub(crate) fn set_eff_perf(&mut self) {
-        let prev = self.prev().map(|prev| { (prev.eff_perf, prev.gas_limit) });
+        let prev = self.prev().map(|prev| (prev.eff_perf, prev.gas_limit));
 
         let mc = self.curr_mut();
         let mut eff_perf = mc.gas_perf * mc.bp;

ipld/blockstore/src/buffered.rs

@@ -307,9 +307,7 @@ mod tests {
         });
         let map_cid = buf_store.put(&map, Code::Blake2b256).unwrap();
 
-        let root_cid = buf_store
-            .put(&(map_cid, 1u8), Code::Blake2b256)
-            .unwrap();
+        let root_cid = buf_store.put(&(map_cid, 1u8), Code::Blake2b256).unwrap();
 
         // Make sure a block not connected to the root does not get written
         let unconnected = buf_store.put(&27u8, Code::Blake2b256).unwrap();

node/forest_libp2p/src/chain_exchange/message.rs

@@ -234,7 +234,11 @@ fn fts_from_bundle_parts(
             let bls_messages = values_from_indexes(&bls_msg_includes[i], &bls_msgs)?;
             let secp_messages = values_from_indexes(&secp_msg_includes[i], &secp_msgs)?;
 
-            Ok(Block { header, bls_messages, secp_messages })
+            Ok(Block {
+                header,
+                bls_messages,
+                secp_messages,
+            })
         })
         .collect::<Result<_, _>>()?;
 

vm/actor/src/builtin/miner/mod.rs

@@ -3583,7 +3583,10 @@ where
     let ret = rt.send(
         *STORAGE_MARKET_ACTOR_ADDR,
         MarketMethod::ComputeDataCommitment as u64,
-        Serialized::serialize(ComputeDataCommitmentParamsRef { deal_ids, sector_type })?,
+        Serialized::serialize(ComputeDataCommitmentParamsRef {
+            deal_ids,
+            sector_type,
+        })?,
         TokenAmount::zero(),
     )?;
     let unsealed_cid: Cid = ret.deserialize()?;

vm/actor/tests/alpha_beta_filter_test.rs

@@ -189,18 +189,9 @@ fn values_in_range() {
         (tens_of_ei_bs.clone(), one_byte_per_epoch_velocity.clone()),
         (tens_of_ei_bs.clone(), ten_pi_bs_per_day_velocity.clone()),
         (tens_of_ei_bs, one_ei_bs_per_day_velocity.clone()),
-        (
-            thousands_of_ei_bs.clone(),
-            one_byte_per_epoch_velocity,
-        ),
-        (
-            thousands_of_ei_bs.clone(),
-            ten_pi_bs_per_day_velocity,
-        ),
-        (
-            thousands_of_ei_bs,
-            one_ei_bs_per_day_velocity,
-        ),
+        (thousands_of_ei_bs.clone(), one_byte_per_epoch_velocity),
+        (thousands_of_ei_bs.clone(), ten_pi_bs_per_day_velocity),
+        (thousands_of_ei_bs, one_ei_bs_per_day_velocity),
     ];
 
     for test_case in test_cases {

vm/actor/tests/common/mod.rs

@@ -574,9 +574,7 @@ impl Runtime<MemoryDB> for MockRuntime {
 
         match expected_msg.exit_code {
             ExitCode::Ok => Ok(expected_msg.send_return),
-            x => {
-                Err(ActorError::new(x, "Expected message Fail".to_string()))
-            }
+            x => Err(ActorError::new(x, "Expected message Fail".to_string())),
         }
     }
 

vm/actor/tests/init_actor_test.rs

@@ -34,8 +34,8 @@ fn abort_cant_call_exec() {
 
     rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, anne);
 
-    let err = exec_and_verify(&mut rt, *POWER_ACTOR_CODE_ID, &"")
-        .expect_err("Exec should have failed");
+    let err =
+        exec_and_verify(&mut rt, *POWER_ACTOR_CODE_ID, &"").expect_err("Exec should have failed");
     assert_eq!(err.exit_code(), ExitCode::ErrForbidden);
 }
 
@@ -103,10 +103,7 @@ fn create_storage_miner() {
     construct_and_verify(&mut rt);
 
     // only the storage power actor can create a miner
-    rt.set_caller(
-        *POWER_ACTOR_CODE_ID,
-        *STORAGE_POWER_ACTOR_ADDR,
-    );
+    rt.set_caller(*POWER_ACTOR_CODE_ID, *STORAGE_POWER_ACTOR_ADDR);
 
     let unique_address = Address::new_actor(b"miner");
     rt.new_actor_addr = Some(unique_address);
@@ -200,10 +197,7 @@ fn sending_constructor_failure() {
     construct_and_verify(&mut rt);
 
     // Only the storage power actor can create a miner
-    rt.set_caller(
-        *POWER_ACTOR_CODE_ID,
-        *STORAGE_POWER_ACTOR_ADDR,
-    );
+    rt.set_caller(*POWER_ACTOR_CODE_ID, *STORAGE_POWER_ACTOR_ADDR);
 
     // Assign new address for the storage actor miner
     let unique_address = Address::new_actor(b"miner");

vm/interpreter/tests/transfer_test.rs

@@ -73,12 +73,7 @@ fn transfer_test() {
         .map_err(|e| e.to_string())
         .unwrap();
 
-    let act_s = ActorState::new(
-        *INIT_ACTOR_CODE_ID,
-        state_cid,
-        Default::default(),
-        1,
-    );
+    let act_s = ActorState::new(*INIT_ACTOR_CODE_ID, state_cid, Default::default(), 1);
     state.set_actor(&INIT_ACTOR_ADDR, act_s).unwrap();
 
     let actor_addr_1 = Address::new_id(100);
@@ -111,12 +106,7 @@ fn transfer_test() {
         10000u64.into(),
         0,
     );
-    let actor_state_2 = ActorState::new(
-        *ACCOUNT_ACTOR_CODE_ID,
-        actor_state_cid_2,
-        1u64.into(),
-        0,
-    );
+    let actor_state_2 = ActorState::new(*ACCOUNT_ACTOR_CODE_ID, actor_state_cid_2, 1u64.into(), 0);
 
     let actor_addr_1 = state.register_new_address(&actor_addr_1).unwrap();
     let actor_addr_2 = state.register_new_address(&actor_addr_2).unwrap();

vm/message/src/unsigned_message.rs

@@ -156,7 +156,18 @@ impl<'de> Deserialize<'de> for UnsignedMessage {
             method_num,
             params,
         ) = Deserialize::deserialize(deserializer)?;
-        Ok(Self { version, from, to, sequence, value, method_num, params, gas_limit, gas_fee_cap, gas_premium })
+        Ok(Self {
+            version,
+            from,
+            to,
+            sequence,
+            value,
+            method_num,
+            params,
+            gas_limit,
+            gas_fee_cap,
+            gas_premium,
+        })
     }
 }
 

vm/src/actor_state.rs

@@ -23,7 +23,12 @@ pub struct ActorState {
 impl ActorState {
     /// Constructor for actor state
     pub fn new(code: Cid, state: Cid, balance: TokenAmount, sequence: u64) -> Self {
-        Self { code, state, sequence, balance }
+        Self {
+            code,
+            state,
+            sequence,
+            balance,
+        }
     }
     /// Safely deducts funds from an Actor
     pub fn deduct_funds(&mut self, amt: &TokenAmount) -> Result<(), String> {

vm/state_tree/tests/state_tree_tests.rs

@@ -68,12 +68,7 @@ fn get_set_non_id() {
         .map_err(|e| e.to_string())
         .unwrap();
 
-    let act_s = ActorState::new(
-        *INIT_ACTOR_CODE_ID,
-        state_cid,
-        Default::default(),
-        1,
-    );
+    let act_s = ActorState::new(*INIT_ACTOR_CODE_ID, state_cid, Default::default(), 1);
 
     tree.snapshot().unwrap();
     tree.set_actor(&INIT_ACTOR_ADDR, act_s).unwrap();