Clippy + fmt

apps/src/lib/cli.rs

@@ -2810,7 +2810,12 @@ pub mod args {
                     "The maximum amount of gas needed to run transaction",
                 ),
             )
-                .arg(EXPIRATION_OPT.def().about("The expiration datetime of the transaction, after which the tx won't be accepted anymore. All of these examples are equivalent:\n2012-12-12T12:12:12Z\n2012-12-12 12:12:12Z\n2012-  12-12T12:  12:12Z"))
+            .arg(EXPIRATION_OPT.def().about(
+                "The expiration datetime of the transaction, after which the \
+                 tx won't be accepted anymore. All of these examples are \
+                 equivalent:\n2012-12-12T12:12:12Z\n2012-12-12 \
+                 12:12:12Z\n2012-  12-12T12:  12:12Z",
+            ))
             .arg(
                 SIGNING_KEY_OPT
                     .def()

apps/src/lib/client/rpc.rs

@@ -1755,9 +1755,9 @@ pub async fn query_bonded_stake(ctx: Context, args: args::QueryBondedStake) {
                     };
                     let is_active = validator_set.active.contains(&weighted);
                     if !is_active {
-                        debug_assert!(validator_set
-                            .inactive
-                            .contains(&weighted));
+                        debug_assert!(
+                            validator_set.inactive.contains(&weighted)
+                        );
                     }
                     println!(
                         "Validator {} is {}, bonded stake: {}",

apps/src/lib/node/ledger/shell/prepare_proposal.rs

@@ -55,7 +55,7 @@ where
                 .into_iter()
                 .map(|tx_bytes| {
                     match Tx::try_from(tx_bytes.as_slice()) {
- Ok(tx) => {
+                         Ok(tx) => {
                             let tx_expiration = tx.expiration;
                             if let Ok(TxType::Wrapper(_)) = process_tx(tx) {
                                 // Check tx expiration against proposed block
@@ -65,40 +65,31 @@ where
                                             Some(&block_time) => {
                                                 match TryInto::<DateTimeUtc>::try_into(block_time.to_owned()) {
                                                     Ok(datetime) => {
-
-if datetime > exp {
-                                                    record::remove(tx_bytes)
-                                                } else {
-                                                    record::keep(tx_bytes)
-                                                }
+                                                        if datetime > exp {
+                                                            record::remove(tx_bytes)
+                                                        } else {
+                                                            record::keep(tx_bytes)
+                                                        }
                                                     },
                                                     Err(_) => {
-
-                                                // Default to last block datetime which has already been checked by mempool_validate, so accept the tx
-                                                record::keep(tx_bytes)
+                                                        // Default to last block datetime which has already been checked by mempool_validate, so accept the tx
+                                                        record::keep(tx_bytes)
                                                     }
                                                 }
                                             },
                                             None => {
-
-                                            // Default to last block datetime which has already been checked by mempool_validate, so accept the tx
-                                            record::keep(tx_bytes)
+                                                // Default to last block datetime which has already been checked by mempool_validate, so accept the tx
+                                                record::keep(tx_bytes)
                                             }
                                         }
                                     },
                                     None => record::keep(tx_bytes)
                                 }
-
-
-                                                       } else {
+                           } else {
                                 record::remove(tx_bytes)
                             }
                         }
                         Err(_) => record::remove(tx_bytes),
-
-
-
-
                                         }
                 })
                 .take_while(|tx_record| {
@@ -129,31 +120,27 @@ if datetime > exp {
                                             Some(block_time) => {
                                                 match TryInto::<DateTimeUtc>::try_into(block_time.to_owned()) {
                                                     Ok(datetime) => {
-
-if datetime > exp {                                                    None
-                                                } else {
-                                                    Some(tx_bytes)
-                                                }
+                                                        if datetime > exp {
+                                                             None
+                                                        } else {
+                                                            Some(tx_bytes)
+                                                        }
                                                     },
                                                     Err(_) => {
-
                                                 // Default to last block datetime which has already been checked by mempool_validate, so accept the tx
                                                 Some(tx_bytes)
                                                     }
                                                 }
                                             },
                                             None => {
-
                                             // Default to last block datetime which has already been checked by mempool_validate, so accept the tx
                                             Some(tx_bytes)
                                             }
                                         }
                                     },
                                     None => Some(tx_bytes)
                                 }
-
-
-                                                       } else {
+                           } else {
                                 None
                             }
                         }
@@ -440,54 +427,53 @@ mod test_prepare_proposal {
     /// Test that expired wrapper transactions are not included in the block
     #[test]
     fn test_expired_wrapper_tx() {
-
-let (shell, _) = TestShell::new();
+        let (shell, _) = TestShell::new();
         let keypair = gen_keypair();
         let tx_time = DateTimeUtc::now();
-let tx = Tx::new(
-                "wasm_code".as_bytes().to_owned(),
-                Some("transaction data".as_bytes().to_owned()),
-                shell.chain_id.clone(),
-                None,
-            );
-                        let wrapper_tx = WrapperTx::new(
-                Fee {
-                    amount: 0.into(),
-                    token: shell.wl_storage.storage.native_token.clone(),
-                },
-                &keypair,
-                0.into(),
-                tx,
-                Default::default(),
-                #[cfg(not(feature = "mainnet"))]
-                None,
-            );
-            let wrapper = wrapper_tx
-                .sign(&keypair, shell.chain_id.clone(), Some(tx_time))
-                .expect("Test failed");
+        let tx = Tx::new(
+            "wasm_code".as_bytes().to_owned(),
+            Some("transaction data".as_bytes().to_owned()),
+            shell.chain_id.clone(),
+            None,
+        );
+        let wrapper_tx = WrapperTx::new(
+            Fee {
+                amount: 0.into(),
+                token: shell.wl_storage.storage.native_token.clone(),
+            },
+            &keypair,
+            0.into(),
+            tx,
+            Default::default(),
+            #[cfg(not(feature = "mainnet"))]
+            None,
+        );
+        let wrapper = wrapper_tx
+            .sign(&keypair, shell.chain_id.clone(), Some(tx_time))
+            .expect("Test failed");
 
-let time = DateTimeUtc::now();
-let mut block_time = namada::core::tendermint_proto::google::protobuf::Timestamp::default();
-        block_time.seconds = 
-time.0.timestamp();
-                block_time.nanos = 
-time.0.timestamp_subsec_nanos() as i32;
-                let req = RequestPrepareProposal {
+        let time = DateTimeUtc::now();
+        let block_time =
+            namada::core::tendermint_proto::google::protobuf::Timestamp {
+                seconds: time.0.timestamp(),
+                nanos: time.0.timestamp_subsec_nanos() as i32,
+            };
+        let req = RequestPrepareProposal {
             txs: vec![wrapper.to_bytes()],
             max_tx_bytes: 0,
-            time: Some(block_time)     ,
-                   ..Default::default()
+            time: Some(block_time),
+            ..Default::default()
         };
         #[cfg(feature = "abcipp")]
         assert_eq!(
             shell.prepare_proposal(req).tx_records,
             vec![record::remove(tx.to_bytes())]
         );
-        #[cfg(not(feature = "abcipp"))] 
+        #[cfg(not(feature = "abcipp"))]
         {
             let result = shell.prepare_proposal(req);
             eprintln!("Proposal: {:?}", result.txs);
-        assert!(result.txs.is_empty());
+            assert!(result.txs.is_empty());
         }
     }
 }

apps/src/lib/node/ledger/shell/process_proposal.rs

@@ -1424,7 +1424,7 @@ mod test_process_proposal {
             },
             &keypair,
             0.into(),
-            tx.clone(),
+            tx,
             Default::default(),
             #[cfg(not(feature = "mainnet"))]
             None,

apps/src/lib/node/ledger/shims/abcipp_shim.rs

@@ -145,18 +145,26 @@ impl AbcippShim {
                                 Ok(t) => t,
                                 Err(_) => {
                                     // Default to last committed block time
-                                    self.service.wl_storage
-                            .storage
-                            .get_last_block_timestamp()
-                            .expect("Failed to retrieve last block timestamp")
+                                    self.service
+                                        .wl_storage
+                                        .storage
+                                        .get_last_block_timestamp()
+                                        .expect(
+                                            "Failed to retrieve last block \
+                                             timestamp",
+                                        )
                                 }
                             },
                             None => {
                                 // Default to last committed block time
-                                self.service.wl_storage
-                            .storage
-                            .get_last_block_timestamp()
-                            .expect("Failed to retrieve last block timestamp")
+                                self.service
+                                    .wl_storage
+                                    .storage
+                                    .get_last_block_timestamp()
+                                    .expect(
+                                        "Failed to retrieve last block \
+                                         timestamp",
+                                    )
                             }
                         },
                         None => {

core/src/ledger/storage/mod.rs

@@ -736,7 +736,7 @@ where
         Ok(self
             .db
             .read_block_header(last_block_height)?
-            .map_or_else(|| DateTimeUtc::now(), |header| header.time))
+            .map_or_else(DateTimeUtc::now, |header| header.time))
     }
 
     /// Initialize a new epoch when the current epoch is finished. Returns

core/src/proto/mod.rs

@@ -7,10 +7,11 @@ pub use types::{Dkg, Error, Signed, SignedTxData, Tx};
 
 #[cfg(test)]
 mod tests {
+    use std::time::SystemTime;
+
     use data_encoding::HEXLOWER;
     use generated::types::Tx;
     use prost::Message;
-    use std::time::SystemTime;
 
     use super::*;
     use crate::types::chain::ChainId;

core/src/types/transaction/decrypted.rs

@@ -93,9 +93,10 @@ pub mod decrypted_tx {
                         .try_to_vec()
                         .expect("Encrypting transaction should not fail"),
                 ),
-                // If undecrytable we cannot extract the ChainId and expiration.
-                // If instead the tx gets decrypted successfully, the correct
-                // chain id and expiration are serialized inside the data field
+                // If undecrytable we cannot extract the ChainId and
+                // expiration. If instead the tx gets decrypted
+                // successfully, the correct chain id and
+                // expiration are serialized inside the data field
                 // of the Tx, while the ones available
                 // in the chain_id and expiration field are just placeholders
                 ChainId(String::new()),

core/src/types/transaction/mod.rs

@@ -246,7 +246,8 @@ pub mod tx_types {
                 vec![],
                 Some(ty.try_to_vec().unwrap()),
                 ChainId(String::new()), /* No need to provide a valid
-                                         * ChainId or expiration when casting back from
+                                         * ChainId or expiration when
+                                         * casting back from
                                          * TxType */
                 None,
             )