fix build

Author: oldGreg5

src/audit/src/lib/tally.rs

@@ -1,4 +1,4 @@
-use bech32::{self, Error as Bech32Error, FromBase32};
+use bech32::{self, FromBase32};
 use bech32::{ToBase32, Variant};
 
 use chain_crypto::{Ed25519, SecretKey};
@@ -11,8 +11,8 @@ use chain_vote::TallyDecryptShare;
 use base64::{engine::general_purpose, Engine as _};
 
 use color_eyre::Result;
-use rand_core::SeedableRng;
 use rand::rngs::StdRng;
+use rand_core::SeedableRng;
 
 /// A Bech32_encoded address consists of 3 parts: A Human-Readable Part (HRP) + Separator + Data:
 const HRP_PK: &str = "ristretto255_memberpk";
@@ -24,9 +24,9 @@ const HRP_SK: &str = "ristretto255_membersk";
 pub fn get_members_secret_share(
     key: String,
 ) -> Result<MemberSecretKey, Box<dyn std::error::Error>> {
-    let (_hrp, data, _variant) = bech32::decode(&key).map_err(Bech32Error::from)?;
+    let (_hrp, data, _variant) = bech32::decode(&key)?;
 
-    let bytes = Vec::<u8>::from_base32(&data).map_err(Bech32Error::from)?;
+    let bytes = Vec::<u8>::from_base32(&data)?;
 
     Ok(MemberSecretKey::from_bytes(&bytes).ok_or("member secret key from bytes")?)
 }
@@ -36,9 +36,9 @@ pub fn get_members_secret_share(
 pub fn get_members_public_share(
     key: String,
 ) -> Result<MemberPublicKey, Box<dyn std::error::Error>> {
-    let (_hrp, data, _variant) = bech32::decode(&key).map_err(Bech32Error::from)?;
+    let (_hrp, data, _variant) = bech32::decode(&key)?;
 
-    let bytes = Vec::<u8>::from_base32(&data).map_err(Bech32Error::from)?;
+    let bytes = Vec::<u8>::from_base32(&data)?;
 
     Ok(MemberPublicKey::from_bytes(&bytes).ok_or("member public key from bytes")?)
 }

src/catalyst-toolbox/catalyst-toolbox/src/ideascale/models/de/clean_string.rs

@@ -74,13 +74,13 @@ pub fn clean_str(s: &str) -> String {
 #[allow(dead_code)]
 mod tests {
     use proptest::arbitrary::any;
-    #[allow(unused_imports)]
-    use serde_json::json;
     use proptest::prelude::*;
     use proptest::{
         arbitrary::{Arbitrary, StrategyFor},
         strategy::Map,
     };
+    #[allow(unused_imports)]
+    use serde_json::json;
     use test_strategy::proptest;
 
     use super::*;

src/catalyst-toolbox/snapshot-lib/src/registration.rs

@@ -253,7 +253,7 @@ pub mod serde_impl {
 
             let addr_type = match addr_type {
                 // Shelley
-                0x0 | 0x1 | 0x2 | 0x3 | 0x4 | 0x5 | 0x6 | 0x7 => AddrType::Shelley,
+                0x0..=0x7 => AddrType::Shelley,
                 // Stake
                 0xf | 0xe => AddrType::Stake,
                 _ => {

src/chain-libs/chain-crypto/src/ec/ristretto255.rs

@@ -254,7 +254,7 @@ impl From<bool> for Scalar {
 // FE + FE
 //////////
 
-impl<'a, 'b> Add<&'b Scalar> for &'a Scalar {
+impl<'b> Add<&'b Scalar> for &Scalar {
     type Output = Scalar;
 
     fn add(self, other: &'b Scalar) -> Scalar {
@@ -268,7 +268,7 @@ std_ops_gen!(Scalar, Add, Scalar, Scalar, add);
 // FE - FE
 //////////
 
-impl<'a, 'b> Sub<&'b Scalar> for &'a Scalar {
+impl<'b> Sub<&'b Scalar> for &Scalar {
     type Output = Scalar;
 
     fn sub(self, other: &'b Scalar) -> Scalar {
@@ -282,7 +282,7 @@ std_ops_gen!(Scalar, Sub, Scalar, Scalar, sub);
 // FE * FE
 //////////
 
-impl<'a, 'b> Mul<&'b Scalar> for &'a Scalar {
+impl<'b> Mul<&'b Scalar> for &Scalar {
     type Output = Scalar;
 
     fn mul(self, other: &'b Scalar) -> Scalar {
@@ -296,15 +296,15 @@ std_ops_gen!(Scalar, Mul, Scalar, Scalar, mul);
 // FE * GE
 //////////
 
-impl<'a, 'b> Mul<&'b GroupElement> for &'a Scalar {
+impl<'b> Mul<&'b GroupElement> for &Scalar {
     type Output = GroupElement;
 
     fn mul(self, other: &'b GroupElement) -> GroupElement {
         other * self
     }
 }
 
-impl<'a, 'b> Mul<&'b Scalar> for &'a GroupElement {
+impl<'b> Mul<&'b Scalar> for &GroupElement {
     type Output = GroupElement;
 
     fn mul(self, other: &'b Scalar) -> GroupElement {
@@ -332,7 +332,7 @@ impl<'a> Mul<&'a GroupElement> for u64 {
     }
 }
 
-impl<'a> Mul<u64> for &'a GroupElement {
+impl Mul<u64> for &GroupElement {
     type Output = GroupElement;
 
     fn mul(self, mut other: u64) -> GroupElement {
@@ -354,7 +354,7 @@ impl<'a> Mul<u64> for &'a GroupElement {
 // GE + GE
 //////////
 
-impl<'a, 'b> Add<&'b GroupElement> for &'a GroupElement {
+impl<'b> Add<&'b GroupElement> for &GroupElement {
     type Output = GroupElement;
 
     fn add(self, other: &'b GroupElement) -> GroupElement {
@@ -368,7 +368,7 @@ std_ops_gen!(GroupElement, Add, GroupElement, GroupElement, add);
 // GE - GE
 //////////
 
-impl<'a, 'b> Sub<&'b GroupElement> for &'a GroupElement {
+impl<'b> Sub<&'b GroupElement> for &GroupElement {
     type Output = GroupElement;
 
     fn sub(self, other: &'b GroupElement) -> GroupElement {

src/chain-libs/chain-impl-mockchain/src/header/version.rs

@@ -77,18 +77,18 @@ impl BlockVersion {
 
     pub const fn get_size(self) -> NonZeroUsize {
         const SIZE: [NonZeroUsize; 3] = [
-            unsafe { NonZeroUsize::new_unchecked(cstruct::HEADER_COMMON_SIZE) },
-            unsafe { NonZeroUsize::new_unchecked(cstruct::HEADER_BFT_SIZE) },
-            unsafe { NonZeroUsize::new_unchecked(cstruct::HEADER_GP_SIZE) },
+            NonZeroUsize::new(cstruct::HEADER_COMMON_SIZE).unwrap(),
+            NonZeroUsize::new(cstruct::HEADER_BFT_SIZE).unwrap(),
+            NonZeroUsize::new(cstruct::HEADER_GP_SIZE).unwrap(),
         ];
         SIZE[self as usize]
     }
 
     pub const fn get_auth_size(self) -> NonZeroUsize {
         const SIZE: [NonZeroUsize; 3] = [
-            unsafe { NonZeroUsize::new_unchecked(cstruct::HEADER_COMMON_SIZE) },
-            unsafe { NonZeroUsize::new_unchecked(cstruct::HEADER_BFT_AUTHED_SIZE) },
-            unsafe { NonZeroUsize::new_unchecked(cstruct::HEADER_GP_AUTHED_SIZE) },
+            NonZeroUsize::new(cstruct::HEADER_COMMON_SIZE).unwrap(),
+            NonZeroUsize::new(cstruct::HEADER_BFT_AUTHED_SIZE).unwrap(),
+            NonZeroUsize::new(cstruct::HEADER_GP_AUTHED_SIZE).unwrap(),
         ];
         SIZE[self as usize]
     }

src/chain-libs/chain-impl-mockchain/src/leadership/bft.rs

@@ -17,7 +17,7 @@ pub struct LeadershipData {
 impl LeadershipData {
     /// Create a new BFT leadership
     pub fn new(leaders: Arc<[BftLeaderId]>) -> Option<Self> {
-        if leaders.len() == 0 {
+        if leaders.is_empty() {
             return None;
         }
 

src/chain-libs/chain-impl-mockchain/src/ledger/governance/mod.rs

@@ -34,7 +34,7 @@ pub struct GovernanceAcceptanceCriteria {
 
 impl Default for GovernanceAcceptanceCriteria {
     fn default() -> Self {
-        const CENT: NonZeroU64 = unsafe { NonZeroU64::new_unchecked(100) };
+        const CENT: NonZeroU64 = NonZeroU64::new(100).unwrap();
 
         Self {
             minimum_stake_participation: Some(Ratio {

src/chain-libs/chain-impl-mockchain/src/multiverse.rs

@@ -110,7 +110,7 @@ impl<State> Multiverse<State> {
     pub fn insert(&mut self, chain_length: ChainLength, k: HeaderId, st: State) -> Ref<State> {
         self.states_by_chain_length
             .entry(chain_length)
-            .or_insert_with(HashSet::new)
+            .or_default()
             .insert(k);
         let state = Arc::new(st);
         self.states_by_hash

src/chain-libs/chain-impl-mockchain/src/setting.rs

@@ -266,14 +266,8 @@ impl Settings {
             self.transaction_max_expiry_epochs,
         ));
 
-        match &self.reward_params {
-            Some(p) => params.push(ConfigParam::RewardParams(p.clone())),
-            None => (),
-        };
-        match &self.treasury_params {
-            Some(p) => params.push(ConfigParam::TreasuryParams(*p)),
-            None => (),
-        };
+        if let Some(p) = &self.reward_params { params.push(ConfigParam::RewardParams(p.clone())) };
+        if let Some(p) = &self.treasury_params { params.push(ConfigParam::TreasuryParams(*p)) };
 
         debug_assert_eq!(self, &Settings::new().try_apply(&params).unwrap());
 

src/chain-libs/chain-impl-mockchain/src/testing/arbitrary/address.rs

@@ -105,24 +105,18 @@ impl Arbitrary for AddressDataValue {
 impl ArbitraryAddressDataValueVec {
     pub fn utxos(&self) -> Vec<AddressDataValue> {
         self.0
-            .iter()
-            .cloned()
-            .filter(|x| matches!(x.address_data.kind(), Kind::Single { .. }))
+            .iter().filter(|&x| matches!(x.address_data.kind(), Kind::Single { .. })).cloned()
             .collect()
     }
     pub fn accounts(&self) -> Vec<AddressDataValue> {
         self.0
-            .iter()
-            .cloned()
-            .filter(|x| matches!(x.address_data.kind(), Kind::Account { .. }))
+            .iter().filter(|&x| matches!(x.address_data.kind(), Kind::Account { .. })).cloned()
             .collect()
     }
 
     pub fn delegations(&self) -> Vec<AddressDataValue> {
         self.0
-            .iter()
-            .cloned()
-            .filter(|x| matches!(x.address_data.kind(), Kind::Group { .. }))
+            .iter().filter(|&x| matches!(x.address_data.kind(), Kind::Group { .. })).cloned()
             .collect()
     }
 }