fix linting

Author: darwinzer0

src/btbe.rs

@@ -59,7 +59,7 @@ impl StoredEntry {
 
         let mut result = [0u8; BTBE_BUCKET_ENTRY_BYTES];
         result[..BTBE_BUCKET_ADDRESS_BYTES].copy_from_slice(address);
-        Ok(Self { 0: result })
+        Ok(Self(result))
     }
 
     fn from(
@@ -159,15 +159,13 @@ impl StoredEntry {
 
     pub fn routes_to_right_node(&self, bit_pos: usize, secret: &[u8]) -> StdResult<bool> {
         // target byte value
-        let byte;
-
         // bit pos is cached
-        if bit_pos < (BTBE_BUCKET_CACHE_BYTES << 3) {
+        let byte = if bit_pos < (BTBE_BUCKET_CACHE_BYTES << 3) {
             // select the byte from cache corresponding to this bit position
-            byte = self.0[BTBE_BUCKET_ADDRESS_BYTES
+            self.0[BTBE_BUCKET_ADDRESS_BYTES
                 + BTBE_BUCKET_BALANCE_BYTES
                 + BTBE_BUCKET_HISTORY_BYTES
-                + (bit_pos >> 3)];
+                + (bit_pos >> 3)]
         }
         // not cached; calculate on the fly
         else {
@@ -180,11 +178,11 @@ impl StoredEntry {
             )?;
 
             // select the byte containing the target bit
-            byte = key_bytes[bit_pos >> 3];
-        }
+            key_bytes[bit_pos >> 3]
+        };
 
         // extract value at bit position and turn into bool
-        return Ok(((byte >> (7 - (bit_pos % 8))) & 1) != 0);
+        Ok(((byte >> (7 - (bit_pos % 8))) & 1) != 0)
     }
 
     pub fn merge_dwb_entry(
@@ -229,9 +227,7 @@ impl StoredEntry {
         // peek at the last tx bundle added (read the dummy one if its void)
         let last_tx_bundle_result = self.get_tx_bundle_at_unchecked(storage, bundle_pos);
         if last_tx_bundle_result.is_err() {
-            return Err(StdError::generic_err(format!(
-                "missing tx bundle while merging dwb entry!",
-            )));
+            return Err(StdError::generic_err("missing tx bundle while merging dwb entry!"));
         }
 
         // unwrap
@@ -469,7 +465,7 @@ pub fn locate_btbe_node(
     // while the node has children
     while node.bucket == 0 {
         // calculate bit value at current bit position
-        let bit_value = (hash[(bit_pos / 8) as usize] >> (7 - (bit_pos % 8))) & 1;
+        let bit_value = (hash[bit_pos / 8] >> (7 - (bit_pos % 8))) & 1;
 
         // increment bit position
         bit_pos += 1;
@@ -584,7 +580,7 @@ pub fn settle_dwb_entry(
     if let Some((idx, mut found_entry)) = bucket.constant_time_find_address(address) {
         // found existing entry
         // merge amount and history from dwb entry
-        found_entry.merge_dwb_entry(storage, &dwb_entry, amount_spent)?;
+        found_entry.merge_dwb_entry(storage, dwb_entry, amount_spent)?;
         bucket.entries[idx] = found_entry;
 
         #[cfg(feature = "gas_tracking")]
@@ -600,7 +596,7 @@ pub fn settle_dwb_entry(
     else {
         // need to insert new entry
         // create new stored balance entry
-        let mut btbe_entry = StoredEntry::from(storage, &dwb_entry, amount_spent)?;
+        let mut btbe_entry = StoredEntry::from(storage, dwb_entry, amount_spent)?;
 
         // cache the address
         btbe_entry.save_hash_cache(storage)?;

src/contract.rs

@@ -153,10 +153,7 @@ pub fn instantiate(
         }
     }
 
-    let supported_denoms = match msg.supported_denoms {
-        None => vec![],
-        Some(x) => x,
-    };
+    let supported_denoms = msg.supported_denoms.unwrap_or_default();
 
     CONFIG.save(
         deps.storage,
@@ -468,7 +465,7 @@ fn permit_queries(
             query::query_balance(deps, account)
         }
         QueryWithPermit::TransferHistory { .. } => {
-            return Err(StdError::generic_err(TRANSFER_HISTORY_UNSUPPORTED_MSG));
+            Err(StdError::generic_err(TRANSFER_HISTORY_UNSUPPORTED_MSG))
         }
         QueryWithPermit::TransactionHistory { page, page_size } => {
             if !permit.check_permission(&TokenPermissions::History) {
@@ -1048,7 +1045,7 @@ mod tests {
             .add_suffix(&alice_entry.head_node().unwrap().to_be_bytes())
             .load(&deps.storage)
             .unwrap()
-            .to_vec(&deps.storage, &deps.api)
+            .as_vec(&deps.storage, &deps.api)
             .unwrap();
 
         let expected_alice_nodes: Vec<Tx> = vec![

src/dwb.rs

@@ -129,7 +129,7 @@ impl DelayedWriteBuffer {
 
         settle_dwb_entry(
             store,
-            &mut dwb_entry,
+            &dwb_entry,
             Some(amount_spent),
             #[cfg(feature = "gas_tracking")]
             tracker,
@@ -178,7 +178,7 @@ impl DelayedWriteBuffer {
         matched_index
     }
 
-    pub fn add_recipient<'a>(
+    pub fn add_recipient(
         &mut self,
         store: &mut dyn Storage,
         rng: &mut ContractPrng,
@@ -196,7 +196,7 @@ impl DelayedWriteBuffer {
         group1.log("recipient_match");
 
         // the new entry will either derive from a prior entry for the recipient or the dummy entry
-        let mut new_entry = self.entries[recipient_index].clone();
+        let mut new_entry = self.entries[recipient_index];
 
         new_entry.set_recipient(recipient)?;
         #[cfg(feature = "gas_tracking")]
@@ -273,10 +273,10 @@ impl DelayedWriteBuffer {
         group1.logf(format!("@write_index: {}", write_index));
 
         // settle the entry
-        let mut dwb_entry = self.entries[actual_settle_index];
+        let dwb_entry = self.entries[actual_settle_index];
         settle_dwb_entry(
             store,
-            &mut dwb_entry,
+            &dwb_entry,
             None,
             #[cfg(feature = "gas_tracking")]
             tracker,
@@ -355,7 +355,7 @@ impl DelayedWriteBufferEntry {
         }
         let mut result = [0u8; DWB_ENTRY_BYTES];
         result[..DWB_RECIPIENT_BYTES].copy_from_slice(recipient);
-        Ok(Self { 0: result })
+        Ok(Self(result))
     }
 
     pub fn recipient_slice(&self) -> &[u8] {
@@ -466,7 +466,7 @@ pub fn amount_u64(amount_spent: Option<u128>) -> StdResult<u64> {
     let amount_spent = amount_spent.unwrap_or_default();
     let amount_spent_u64 = amount_spent
         .try_into()
-        .or_else(|_| return Err(StdError::generic_err("se: spent overflow")))?;
+        .map_err(|_| StdError::generic_err("se: spent overflow"))?;
     Ok(amount_spent_u64)
 }
 
@@ -481,7 +481,7 @@ pub struct TxNode {
 
 impl TxNode {
     // converts this and following elements in list to a vec of Tx
-    pub fn to_vec(&self, store: &dyn Storage, api: &dyn Api) -> StdResult<Vec<Tx>> {
+    pub fn as_vec(&self, store: &dyn Storage, api: &dyn Api) -> StdResult<Vec<Tx>> {
         let mut result = vec![];
         let mut cur_node = Some(self.to_owned());
         while cur_node.is_some() {

src/execute_admin.rs

@@ -10,7 +10,7 @@ pub fn change_admin(deps: DepsMut, constants: &mut Config, address: String) -> S
     let address = deps.api.addr_validate(address.as_str())?;
 
     constants.admin = address;
-    CONFIG.save(deps.storage, &constants)?;
+    CONFIG.save(deps.storage, constants)?;
 
     Ok(Response::new().set_data(to_binary(&ExecuteAnswer::ChangeAdmin { status: Success })?))
 }
@@ -32,7 +32,7 @@ pub fn add_supported_denoms(
         }
     }
 
-    CONFIG.save(deps.storage, &config)?;
+    CONFIG.save(deps.storage, config)?;
 
     Ok(
         Response::new().set_data(to_binary(&ExecuteAnswer::AddSupportedDenoms {
@@ -56,7 +56,7 @@ pub fn remove_supported_denoms(
         config.supported_denoms.retain(|x| x != denom);
     }
 
-    CONFIG.save(deps.storage, &config)?;
+    CONFIG.save(deps.storage, config)?;
 
     Ok(
         Response::new().set_data(to_binary(&ExecuteAnswer::RemoveSupportedDenoms {

src/execute_mint_burn.rs

@@ -212,6 +212,7 @@ fn try_mint_impl(
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn perform_mint(
     store: &mut dyn Storage,
     rng: &mut ContractPrng,
@@ -453,7 +454,7 @@ pub fn try_burn_from(
                 memo_len,
             },
         )
-        .to_txhash_notification(deps.api, &env, secret, None)?;
+        .to_txhash_notification(deps.api, env, secret, None)?;
 
         resp = resp.add_attribute_plaintext(
             spent_notification.id_plaintext(),

src/execute_transfer_send.rs

@@ -230,10 +230,10 @@ pub fn try_transfer_from(
 
     if NOTIFICATIONS_ENABLED.load(deps.storage)? {
         let received_notification =
-            received_notification.to_txhash_notification(deps.api, &env, secret, None)?;
+            received_notification.to_txhash_notification(deps.api, env, secret, None)?;
 
         let spent_notification =
-            spent_notification.to_txhash_notification(deps.api, &env, secret, None)?;
+            spent_notification.to_txhash_notification(deps.api, env, secret, None)?;
 
         resp = resp
             .add_attribute_plaintext(
@@ -846,6 +846,7 @@ fn try_send_from_impl(
     Ok((received_notification, spent_notification))
 }
 
+#[allow(clippy::too_many_arguments)]
 fn perform_transfer(
     store: &mut dyn Storage,
     rng: &mut ContractPrng,

src/gas_tracker.rs

@@ -76,7 +76,7 @@ impl<'a, 'b> GasGroup<'a, 'b> {
             format!(
                 "{}:{}:{}",
                 self.index,
-                gas.unwrap_or(0u64).to_string(),
+                gas.unwrap_or(0u64),
                 comment
             ),
         );

src/notifications.rs

@@ -196,7 +196,7 @@ impl GroupChannel<RecvdNotification> for MultiRecvdNotification {
         let owner_bytes: &[u8];
         if let Some(owner) = &data.sender {
             owner_addr = api.addr_canonicalize(owner.as_str())?;
-            owner_bytes = &owner_addr.as_slice()
+            owner_bytes = owner_addr.as_slice()
         } else {
             owner_bytes = &ZERO_ADDR;
         }
@@ -298,10 +298,10 @@ impl BloomFilter {
     fn add<D: DirectChannel, G: GroupChannel<D>>(
         &mut self,
         recipient: &CanonicalAddr,
-        packet_plaintext: &Vec<u8>,
+        packet_plaintext: &[u8],
     ) -> StdResult<Vec<u8>> {
         // contribute to received bloom filter
-        let seed = get_seed(&recipient, &self.secret)?;
+        let seed = get_seed(recipient, &self.secret)?;
         let id = notification_id(&seed, G::CHANNEL_ID, &self.tx_hash)?;
         let hash_bytes = U256::from_big_endian(&sha_256(id.0.as_slice()));
         let bloom_mask: U256 = U256::from(G::BLOOM_M - 1);

src/query.rs

@@ -118,7 +118,7 @@ pub fn query_transactions(
             let head_node = TX_NODES
                 .add_suffix(&head_node_index.to_be_bytes())
                 .load(deps.storage)?;
-            txs_in_dwb = head_node.to_vec(deps.storage, deps.api)?;
+            txs_in_dwb = head_node.as_vec(deps.storage, deps.api)?;
         }
     }
 
@@ -148,7 +148,7 @@ pub fn query_transactions(
             if tx_bundles_idx_len > 0 {
                 let mut bundle_idx = tx_bundles_idx_len - 1;
                 loop {
-                    let tx_bundle = entry.get_tx_bundle_at(deps.storage, bundle_idx.clone())?;
+                    let tx_bundle = entry.get_tx_bundle_at(deps.storage, bundle_idx)?;
 
                     // only look if head node is not null
                     if tx_bundle.head_node > 0 {
@@ -159,11 +159,11 @@ pub fn query_transactions(
                         let list_len = tx_bundle.list_len as u32;
                         if txs_left <= list_len {
                             txs.extend_from_slice(
-                                &head_node.to_vec(deps.storage, deps.api)?[0..txs_left as usize],
+                                &head_node.as_vec(deps.storage, deps.api)?[0..txs_left as usize],
                             );
                             break;
                         }
-                        txs.extend(head_node.to_vec(deps.storage, deps.api)?);
+                        txs.extend(head_node.as_vec(deps.storage, deps.api)?);
                         txs_left = txs_left.saturating_sub(list_len);
                     }
                     if bundle_idx > 0 {
@@ -197,7 +197,7 @@ pub fn query_transactions(
                         .add_suffix(&tx_bundle.head_node.to_be_bytes())
                         .load(deps.storage)?;
                     // this first bundle has all the txs we need
-                    txs = head_node.to_vec(deps.storage, deps.api)?
+                    txs = head_node.as_vec(deps.storage, deps.api)?
                         [start_at as usize..(start_at + txs_left) as usize]
                         .to_vec();
                 }
@@ -208,7 +208,7 @@ pub fn query_transactions(
                         .add_suffix(&tx_bundle.head_node.to_be_bytes())
                         .load(deps.storage)?;
                     // get the rest of the txs in this bundle and then go back through history
-                    txs = head_node.to_vec(deps.storage, deps.api)?[start_at as usize..].to_vec();
+                    txs = head_node.as_vec(deps.storage, deps.api)?[start_at as usize..].to_vec();
                     txs_left = txs_left.saturating_sub(list_len - start_at);
                 }
 
@@ -218,7 +218,7 @@ pub fn query_transactions(
                     if let Some(entry) = account_stored_entry {
                         loop {
                             let tx_bundle =
-                                entry.get_tx_bundle_at(deps.storage, bundle_idx.clone())?;
+                                entry.get_tx_bundle_at(deps.storage, bundle_idx)?;
                             // only look if head node is not null
                             if tx_bundle.head_node > 0 {
                                 let head_node = TX_NODES
@@ -227,12 +227,12 @@ pub fn query_transactions(
                                 let list_len = tx_bundle.list_len as u32;
                                 if txs_left <= list_len {
                                     txs.extend_from_slice(
-                                        &head_node.to_vec(deps.storage, deps.api)?
+                                        &head_node.as_vec(deps.storage, deps.api)?
                                             [0..txs_left as usize],
                                     );
                                     break;
                                 }
-                                txs.extend(head_node.to_vec(deps.storage, deps.api)?);
+                                txs.extend(head_node.as_vec(deps.storage, deps.api)?);
                                 txs_left = txs_left.saturating_sub(list_len);
                             }
                             if bundle_idx > 0 {
@@ -335,7 +335,7 @@ pub fn query_allowances_given(
     let owner = Addr::unchecked(owner);
 
     let all_allowances =
-        AllowancesStore::all_allowances(deps.storage, &owner, page, page_size).unwrap_or(vec![]);
+        AllowancesStore::all_allowances(deps.storage, &owner, page, page_size).unwrap_or_default();
 
     let allowances_result = all_allowances
         .into_iter()
@@ -367,7 +367,7 @@ pub fn query_allowances_received(
     let spender = Addr::unchecked(spender);
 
     let all_allowed =
-        AllowancesStore::all_allowed(deps.storage, &spender, page, page_size).unwrap_or(vec![]);
+        AllowancesStore::all_allowed(deps.storage, &spender, page, page_size).unwrap_or_default();
 
     let allowances = all_allowed
         .into_iter()