diff --git a/.github/workflows/run-tests-on-push-to-main.yml b/.github/workflows/run-tests-on-push-to-main.yml index 7fdab789..0564784b 100644 --- a/.github/workflows/run-tests-on-push-to-main.yml +++ b/.github/workflows/run-tests-on-push-to-main.yml @@ -24,7 +24,7 @@ jobs: run: cargo fmt --all -- --check - name: Run Clippy - run: cargo clippy --all-targets --all-features + run: cargo clippy --all-targets --all-features -- -D warnings - name: Run Build run: cargo build --verbose diff --git a/codec/src/map_parameters.rs b/codec/src/map_parameters.rs index f470d3f8..d206fa50 100644 --- a/codec/src/map_parameters.rs +++ b/codec/src/map_parameters.rs @@ -198,7 +198,7 @@ pub fn map_nullable_gov_action_id( fn map_constitution(constitution: &conway::Constitution) -> Constitution { Constitution { anchor: map_anchor(&constitution.anchor), - guardrail_script: map_nullable(|x| to_hash(x), &constitution.guardrail_script), + guardrail_script: map_nullable(to_hash, &constitution.guardrail_script), } } diff --git a/common/src/address.rs b/common/src/address.rs index 7a3bfa40..1dd20723 100644 --- a/common/src/address.rs +++ b/common/src/address.rs @@ -398,8 +398,8 @@ impl StakeAddress { pub fn get_credential(&self) -> Credential { match &self.credential { - StakeCredential::AddrKeyHash(hash) => Credential::AddrKeyHash(hash.clone()), - StakeCredential::ScriptHash(hash) => Credential::ScriptHash(hash.clone()), + StakeCredential::AddrKeyHash(hash) => Credential::AddrKeyHash(*hash), + StakeCredential::ScriptHash(hash) => Credential::ScriptHash(*hash), } } @@ -411,7 +411,7 @@ impl StakeAddress { }; let data = self.to_binary(); - Ok(bech32::encode::(hrp, &data.as_slice())?) + Ok(bech32::encode::(hrp, data.as_slice())?) } /// Read from a string format ("stake1xxx...") @@ -520,7 +520,7 @@ impl minicbor::Encode for StakeAddress { _ctx: &mut C, ) -> Result<(), minicbor::encode::Error> { let data = self.to_binary(); - e.bytes(&data.as_slice())?; + e.bytes(data.as_slice())?; Ok(()) } } @@ -902,7 +902,7 @@ mod tests { assert_eq!(sa.network, NetworkId::Mainnet); assert_eq!( match sa.credential { - StakeCredential::AddrKeyHash(key) => hex::encode(&key), + StakeCredential::AddrKeyHash(key) => hex::encode(key), _ => "SCRIPT".to_string(), }, "558f3ee09b26d88fac2eddc772a9eda94cce6dbadbe9fee439bd6001" @@ -918,7 +918,7 @@ mod tests { assert_eq!(sa.network, NetworkId::Mainnet); assert_eq!( match sa.credential { - StakeCredential::ScriptHash(key) => hex::encode(&key), + StakeCredential::ScriptHash(key) => hex::encode(key), _ => "STAKE".to_string(), }, "558f3ee09b26d88fac2eddc772a9eda94cce6dbadbe9fee439bd6001" @@ -934,7 +934,7 @@ mod tests { assert_eq!(sa.network, NetworkId::Testnet); assert_eq!( match sa.credential { - StakeCredential::AddrKeyHash(key) => hex::encode(&key), + StakeCredential::AddrKeyHash(key) => hex::encode(key), _ => "SCRIPT".to_string(), }, "558f3ee09b26d88fac2eddc772a9eda94cce6dbadbe9fee439bd6001" @@ -963,7 +963,7 @@ mod tests { // - 0x1d: Length of 29 bytes (the stake address data) // - [29 bytes]: The actual stake address (network header + 28-byte hash) // Total: 31 bytes (2-byte CBOR framing + 29-byte payload) - let expected = [[0x58, 0x1d].as_slice(), &binary.as_slice()].concat(); + let expected = [[0x58, 0x1d].as_slice(), binary.as_slice()].concat(); let mut actual = Vec::new(); let mut encoder = minicbor::Encoder::new(&mut actual); @@ -977,7 +977,7 @@ mod tests { fn stake_addresses_decode_mainnet_stake() { let binary = { let mut v = vec![0x58, 0x1d]; - v.extend_from_slice(&mainnet_stake_address().to_binary().as_slice()); + v.extend_from_slice(mainnet_stake_address().to_binary().as_slice()); v }; @@ -987,7 +987,7 @@ mod tests { assert_eq!(decoded.network, NetworkId::Mainnet); assert_eq!( match decoded.credential { - StakeCredential::AddrKeyHash(key) => hex::encode(&key), + StakeCredential::AddrKeyHash(key) => hex::encode(key), _ => "STAKE".to_string(), }, "558f3ee09b26d88fac2eddc772a9eda94cce6dbadbe9fee439bd6001" @@ -1010,7 +1010,7 @@ mod tests { assert_eq!(decoded.network, NetworkId::Mainnet); assert_eq!( match decoded.credential { - StakeCredential::ScriptHash(key) => hex::encode(&key), + StakeCredential::ScriptHash(key) => hex::encode(key), _ => "STAKE".to_string(), }, "558f3ee09b26d88fac2eddc772a9eda94cce6dbadbe9fee439bd6001" @@ -1031,7 +1031,7 @@ mod tests { assert_eq!(decoded.network, NetworkId::Testnet); assert_eq!( match decoded.credential { - StakeCredential::ScriptHash(key) => hex::encode(&key), + StakeCredential::ScriptHash(key) => hex::encode(key), _ => "SCRIPT".to_string(), }, "558f3ee09b26d88fac2eddc772a9eda94cce6dbadbe9fee439bd6001" diff --git a/common/src/crypto.rs b/common/src/crypto.rs index f5a0d2cf..019b3550 100644 --- a/common/src/crypto.rs +++ b/common/src/crypto.rs @@ -9,7 +9,7 @@ use cryptoxide::hashing::blake2b::Blake2b; pub fn keyhash_256(key: &[u8]) -> Hash<32> { let mut context = Blake2b::<256>::new(); context.update_mut(key); - Hash::new(context.finalize().into()) + Hash::new(context.finalize()) } /// Get a Blake2b-224 hash of a key @@ -18,5 +18,5 @@ pub fn keyhash_256(key: &[u8]) -> Hash<32> { pub fn keyhash_224(key: &[u8]) -> Hash<28> { let mut context = Blake2b::<224>::new(); context.update_mut(key); - Hash::new(context.finalize().into()) + Hash::new(context.finalize()) } diff --git a/common/src/hash.rs b/common/src/hash.rs index 6a33306e..71100a53 100644 --- a/common/src/hash.rs +++ b/common/src/hash.rs @@ -312,10 +312,10 @@ macro_rules! declare_hash_type_with_bech32 { } } - impl crate::serialization::Bech32Conversion for $name { + impl $crate::serialization::Bech32Conversion for $name { fn to_bech32(&self) -> Result { - use crate::serialization::Bech32WithHrp; use anyhow::Context; + use $crate::serialization::Bech32WithHrp; self.as_ref().to_bech32_with_hrp($hrp).with_context(|| { format!( @@ -327,8 +327,8 @@ macro_rules! declare_hash_type_with_bech32 { } fn from_bech32(s: &str) -> Result { - use crate::serialization::Bech32WithHrp; use anyhow::Context; + use $crate::serialization::Bech32WithHrp; let v = Vec::::from_bech32_with_hrp(s, $hrp).with_context(|| { format!("Failed to decode {} from bech32", stringify!($name)) diff --git a/common/src/queries/blocks.rs b/common/src/queries/blocks.rs index efb35e6d..b196a1ae 100644 --- a/common/src/queries/blocks.rs +++ b/common/src/queries/blocks.rs @@ -157,7 +157,7 @@ impl Serialize for BlockInfo { "block_vrf", &self.block_vrf.and_then(|vkey| vkey.to_bech32().ok()), )?; - state.serialize_field("op_cert", &self.op_cert.clone().map(hex::encode))?; + state.serialize_field("op_cert", &self.op_cert.map(hex::encode))?; state.serialize_field("op_cert_counter", &self.op_cert_counter)?; state.serialize_field("previous_block", &self.previous_block)?; state.serialize_field("next_block", &self.next_block)?; diff --git a/common/src/stake_addresses.rs b/common/src/stake_addresses.rs index 7eaeb44f..43f38ea3 100644 --- a/common/src/stake_addresses.rs +++ b/common/src/stake_addresses.rs @@ -150,14 +150,11 @@ impl StakeAddressMap { let sas_data: Vec<(PoolId, u64)> = self .inner .values() - .filter_map(|sas| sas.delegated_spo.as_ref().map(|spo| (spo.clone(), sas.utxo_value))) + .filter_map(|sas| sas.delegated_spo.as_ref().map(|spo| (*spo, sas.utxo_value))) .collect(); sas_data.iter().for_each(|(spo, utxo_value)| { - live_stakes_map - .entry(spo.clone()) - .and_modify(|v| *v += utxo_value) - .or_insert(*utxo_value); + live_stakes_map.entry(*spo).and_modify(|v| *v += utxo_value).or_insert(*utxo_value); }); spos.iter() @@ -298,7 +295,7 @@ impl StakeAddressMap { .inner .values() .filter_map(|sas| { - sas.delegated_spo.as_ref().map(|spo| (spo.clone(), (sas.utxo_value, sas.rewards))) + sas.delegated_spo.as_ref().map(|spo| (*spo, (sas.utxo_value, sas.rewards))) }) .collect(); @@ -307,7 +304,7 @@ impl StakeAddressMap { .par_iter() // Rayon multi-threaded iterator .for_each(|(spo, (utxo_value, rewards))| { spo_stakes - .entry(spo.clone()) + .entry(*spo) .and_modify(|v| { v.active += *utxo_value; v.active_delegators_count += 1; @@ -321,7 +318,7 @@ impl StakeAddressMap { }); // Collect into a plain BTreeMap, so that it is ordered on output - spo_stakes.iter().map(|entry| (entry.key().clone(), *entry.value())).collect() + spo_stakes.iter().map(|entry| (*entry.key(), *entry.value())).collect() } /// Dump current Stake Pool Delegation Distribution State @@ -331,7 +328,7 @@ impl StakeAddressMap { .inner .par_iter() .filter_map(|(key, sas)| { - sas.delegated_spo.as_ref().map(|spo| (spo.clone(), (key.clone(), sas.utxo_value))) + sas.delegated_spo.as_ref().map(|spo| (*spo, (key.clone(), sas.utxo_value))) }) .collect(); @@ -436,7 +433,7 @@ impl StakeAddressMap { pub fn record_stake_delegation(&mut self, stake_address: &StakeAddress, spo: &PoolId) -> bool { if let Some(sas) = self.get_mut(stake_address) { if sas.registered { - sas.delegated_spo = Some(spo.clone()); + sas.delegated_spo = Some(*spo); true } else { error!( @@ -1251,8 +1248,8 @@ mod tests { let map = stake_addresses.get_accounts_utxo_values_map(&keys).unwrap(); assert_eq!(map.len(), 2); - assert_eq!(map.get(&addr1.get_hash()).copied().unwrap(), 1000); - assert_eq!(map.get(&addr2.get_hash()).copied().unwrap(), 2000); + assert_eq!(map.get(addr1.get_hash()).copied().unwrap(), 1000); + assert_eq!(map.get(addr2.get_hash()).copied().unwrap(), 2000); } #[test] @@ -1365,8 +1362,8 @@ mod tests { let map = stake_addresses.get_accounts_balances_map(&addresses).unwrap(); assert_eq!(map.len(), 2); - assert_eq!(map.get(&addr1.get_hash()).copied().unwrap(), 1100); - assert_eq!(map.get(&addr2.get_hash()).copied().unwrap(), 2000); + assert_eq!(map.get(addr1.get_hash()).copied().unwrap(), 1100); + assert_eq!(map.get(addr2.get_hash()).copied().unwrap(), 2000); } #[test] @@ -1474,14 +1471,14 @@ mod tests { assert_eq!(map.len(), 3); assert_eq!( - map.get(&addr1.get_hash()).unwrap(), + map.get(addr1.get_hash()).unwrap(), &Some(DRepChoice::Abstain) ); assert_eq!( - map.get(&addr2.get_hash()).unwrap(), + map.get(addr2.get_hash()).unwrap(), &Some(DRepChoice::Key(DREP_HASH)) ); - assert_eq!(map.get(&addr3.get_hash()).unwrap(), &None); + assert_eq!(map.get(addr3.get_hash()).unwrap(), &None); } #[test] diff --git a/common/src/types.rs b/common/src/types.rs index 0de8c9fc..560258c2 100644 --- a/common/src/types.rs +++ b/common/src/types.rs @@ -723,11 +723,10 @@ impl Credential { } pub fn get_hash(&self) -> KeyHash { - match self { + *match self { Self::AddrKeyHash(hash) => hash, Self::ScriptHash(hash) => hash, } - .clone() } pub fn from_drep_bech32(bech32_str: &str) -> Result { diff --git a/modules/accounts_state/src/accounts_state.rs b/modules/accounts_state/src/accounts_state.rs index 11a16def..82630f03 100644 --- a/modules/accounts_state/src/accounts_state.rs +++ b/modules/accounts_state/src/accounts_state.rs @@ -510,7 +510,7 @@ impl AccountsState { AccountsStateQueryResponse::AccountInfo(AccountInfo { utxo_value: account.utxo_value, rewards: account.rewards, - delegated_spo: account.delegated_spo.clone(), + delegated_spo: account.delegated_spo, delegated_drep: account.delegated_drep.clone(), }) } else { diff --git a/modules/accounts_state/src/rewards.rs b/modules/accounts_state/src/rewards.rs index fb5b6f64..4ecabafd 100644 --- a/modules/accounts_state/src/rewards.rs +++ b/modules/accounts_state/src/rewards.rs @@ -213,8 +213,8 @@ pub fn calculate_rewards( result.total_paid += reward.amount; } - result.rewards.insert(operator_id.clone(), rewards); - result.spo_rewards.push((operator_id.clone(), spo_rewards)); + result.rewards.insert(*operator_id, rewards); + result.spo_rewards.push((*operator_id, spo_rewards)); } } diff --git a/modules/accounts_state/src/snapshot.rs b/modules/accounts_state/src/snapshot.rs index bd0154fa..73ae465f 100644 --- a/modules/accounts_state/src/snapshot.rs +++ b/modules/accounts_state/src/snapshot.rs @@ -105,7 +105,7 @@ impl Snapshot { // Add the new one snapshot.spos.insert( - spo_id.clone(), + *spo_id, SnapshotSPO { delegators: vec![], total_stake: 0, @@ -229,7 +229,7 @@ mod tests { StakeAddressState { utxo_value: 42, registered: true, - delegated_spo: Some(spo1.clone()), + delegated_spo: Some(spo1), ..StakeAddressState::default() }, ); @@ -238,7 +238,7 @@ mod tests { StakeAddressState { utxo_value: 99, registered: true, - delegated_spo: Some(spo2.clone()), + delegated_spo: Some(spo2), ..StakeAddressState::default() }, ); @@ -247,7 +247,7 @@ mod tests { StakeAddressState { utxo_value: 0, registered: true, - delegated_spo: Some(spo1.clone()), + delegated_spo: Some(spo1), ..StakeAddressState::default() }, ); @@ -271,8 +271,8 @@ mod tests { ); let mut spos: OrdMap = OrdMap::new(); - spos.insert(spo1.clone(), PoolRegistration::default()); - spos.insert(spo2.clone(), PoolRegistration::default()); + spos.insert(spo1, PoolRegistration::default()); + spos.insert(spo2, PoolRegistration::default()); let spo_block_counts: HashMap = HashMap::new(); let snapshot = Snapshot::new( 42, @@ -313,7 +313,7 @@ mod tests { let addr4 = create_test_stake_address(0x14); snapshot.spos.insert( - spo1.clone(), + spo1, SnapshotSPO { delegators: vec![ (addr1.clone(), 100), @@ -340,7 +340,7 @@ mod tests { let addr_x = create_test_stake_address(0x99); snapshot.spos.insert( - spo1.clone(), + spo1, SnapshotSPO { delegators: vec![(addr1.clone(), 100)], total_stake: 100, @@ -369,7 +369,7 @@ mod tests { let addr1 = create_test_stake_address(0x11); snapshot.spos.insert( - spo1.clone(), + spo1, SnapshotSPO { delegators: vec![(addr1.clone(), 100)], total_stake: 100, diff --git a/modules/accounts_state/src/spo_distribution_store.rs b/modules/accounts_state/src/spo_distribution_store.rs index cdf6b02e..0a041e0e 100644 --- a/modules/accounts_state/src/spo_distribution_store.rs +++ b/modules/accounts_state/src/spo_distribution_store.rs @@ -230,11 +230,11 @@ mod tests { const DB_PATH: &str = "spdd_db"; fn test_pool_hash(byte: u8) -> PoolId { - keyhash_224(&vec![byte]).into() + keyhash_224(&[byte]).into() } fn test_addr_hash(byte: u8) -> AddrKeyhash { - keyhash_224(&vec![byte]) + keyhash_224(&[byte]) } #[test] diff --git a/modules/accounts_state/src/state.rs b/modules/accounts_state/src/state.rs index 787ed0d2..63f9ccfe 100644 --- a/modules/accounts_state/src/state.rs +++ b/modules/accounts_state/src/state.rs @@ -626,7 +626,7 @@ impl State { stake_address: reward.account.clone(), delta: reward.amount, reward_type: reward.rtype.clone(), - pool: reward.pool.clone(), + pool: reward.pool, }); } else { warn!( @@ -670,7 +670,7 @@ impl State { .spo_blocks .iter() .filter(|(hash, _)| self.spos.contains_key(hash)) - .map(|(hash, count)| (hash.clone(), *count)) + .map(|(hash, count)| (*hash, *count)) .collect(); // Enter epoch - note the message specifies the epoch that has just *ended* @@ -689,7 +689,7 @@ impl State { pub fn handle_spo_state(&mut self, spo_msg: &SPOStateMessage) -> Result<()> { // Capture current SPOs, mapped by operator ID let new_spos: OrdMap = - spo_msg.spos.iter().cloned().map(|spo| (spo.operator.clone(), spo)).collect(); + spo_msg.spos.iter().cloned().map(|spo| (spo.operator, spo)).collect(); // Get pool deposit amount from parameters, or default let deposit = self @@ -755,10 +755,7 @@ impl State { hex::encode(id), retired_spo.reward_account ); - self.pool_refunds.push(( - retired_spo.operator.clone(), - retired_spo.reward_account.clone(), - )); + self.pool_refunds.push((retired_spo.operator, retired_spo.reward_account.clone())); // Store full StakeAddress } @@ -985,7 +982,7 @@ mod tests { } fn test_keyhash(byte: u8) -> KeyHash { - keyhash_224(&vec![byte]) + keyhash_224(&[byte]) } fn test_keyhash_from_bytes(bytes: &[u8]) -> KeyHash { @@ -993,7 +990,7 @@ mod tests { } fn test_vrf_keyhash(byte: u8) -> VrfKeyHash { - keyhash_256(&vec![byte]).into() + keyhash_256(&[byte]).into() } const STAKE_KEY_HASH: [u8; 3] = [0x99, 0x0f, 0x00]; diff --git a/modules/accounts_state/src/verifier.rs b/modules/accounts_state/src/verifier.rs index b3f162d2..a4337fab 100644 --- a/modules/accounts_state/src/verifier.rs +++ b/modules/accounts_state/src/verifier.rs @@ -195,7 +195,7 @@ impl Verifier { Left(expected_spo) => { error!( "Missing rewards SPO: {} {} rewards", - hex::encode(&expected_spo.0), + hex::encode(expected_spo.0), expected_spo.1.len() ); errors += 1; @@ -203,7 +203,7 @@ impl Verifier { Right(actual_spo) => { error!( "Extra rewards SPO: {} {} rewards", - hex::encode(&actual_spo.0), + hex::encode(actual_spo.0), actual_spo.1.len() ); errors += 1; @@ -222,7 +222,7 @@ impl Verifier { Left(expected) => { error!( "Missing reward: SPO {} account {} {:?} {}", - hex::encode(&expected_spo.0), + hex::encode(expected_spo.0), expected.account, expected.rtype, expected.amount @@ -232,7 +232,7 @@ impl Verifier { Right(actual) => { error!( "Extra reward: SPO {} account {} {:?} {}", - hex::encode(&actual_spo.0), + hex::encode(actual_spo.0), actual.account, actual.rtype, actual.amount @@ -242,7 +242,7 @@ impl Verifier { Both(expected, actual) => { if expected.amount != actual.amount { error!("Different reward: SPO {} account {} {:?} expected {}, actual {} ({})", - hex::encode(&expected_spo.0), + hex::encode(expected_spo.0), expected.account, expected.rtype, expected.amount, @@ -252,7 +252,7 @@ impl Verifier { } else { debug!( "Reward match: SPO {} account {} {:?} {}", - hex::encode(&expected_spo.0), + hex::encode(expected_spo.0), expected.account, expected.rtype, expected.amount diff --git a/modules/drep_state/src/state.rs b/modules/drep_state/src/state.rs index 6f48b4a0..054e55a5 100644 --- a/modules/drep_state/src/state.rs +++ b/modules/drep_state/src/state.rs @@ -261,8 +261,8 @@ impl State { for (tx_hash, voting_procedures) in voting_procedures { for (voter, single_votes) in &voting_procedures.votes { let drep_cred = match voter { - Voter::DRepKey(k) => DRepCredential::AddrKeyHash(k.into_inner().into()), - Voter::DRepScript(s) => DRepCredential::ScriptHash(s.into_inner().into()), + Voter::DRepKey(k) => DRepCredential::AddrKeyHash(k.into_inner()), + Voter::DRepScript(s) => DRepCredential::ScriptHash(s.into_inner()), _ => continue, }; @@ -559,8 +559,8 @@ impl State { fn drep_choice_to_credential(choice: &DRepChoice) -> Option { match choice { - DRepChoice::Key(k) => Some(DRepCredential::AddrKeyHash(k.clone())), - DRepChoice::Script(k) => Some(DRepCredential::ScriptHash(k.clone())), + DRepChoice::Key(k) => Some(DRepCredential::AddrKeyHash(*k)), + DRepChoice::Script(k) => Some(DRepCredential::ScriptHash(*k)), _ => None, } } diff --git a/modules/epochs_state/src/state.rs b/modules/epochs_state/src/state.rs index a2a29a55..cbd3792b 100644 --- a/modules/epochs_state/src/state.rs +++ b/modules/epochs_state/src/state.rs @@ -191,7 +191,7 @@ impl State { let spo_id = PoolId::from(keyhash_224(issuer_vkey)); // Count one on this hash - *(self.blocks_minted.entry(spo_id.clone()).or_insert(0)) += 1; + *(self.blocks_minted.entry(spo_id).or_insert(0)) += 1; } // Handle Block Txs @@ -250,7 +250,7 @@ impl State { total_txs: self.epoch_txs, total_outputs: self.epoch_outputs, total_fees: self.epoch_fees, - spo_blocks: self.blocks_minted.iter().map(|(k, v)| (k.clone(), *v)).collect(), + spo_blocks: self.blocks_minted.iter().map(|(k, v)| (*k, *v)).collect(), nonce: self.nonces.as_ref().and_then(|n| n.active.hash), } } diff --git a/modules/governance_state/src/alonzo_babbage_voting.rs b/modules/governance_state/src/alonzo_babbage_voting.rs index c0d1b5c9..f4992e5d 100644 --- a/modules/governance_state/src/alonzo_babbage_voting.rs +++ b/modules/governance_state/src/alonzo_babbage_voting.rs @@ -52,7 +52,7 @@ impl AlonzoBabbageVoting { let entry = self.proposals.entry(pp.enactment_epoch + 1).or_default(); for (k, p) in &pp.proposals { // A new proposal for key k always replaces the old one - entry.insert(k.clone(), (block_info.epoch, block_info.slot, p.clone())); + entry.insert(*k, (block_info.epoch, block_info.slot, p.clone())); } } @@ -71,7 +71,7 @@ impl AlonzoBabbageVoting { let proposals = proposals_for_new_epoch .iter() .filter(|(_k, (_epoch, slot, _proposal))| self.is_timely_vote(*slot, new_blk)) - .map(|(k, (_e, _s, proposal))| (k.clone(), proposal.clone())) + .map(|(k, (_e, _s, proposal))| (*k, proposal.clone())) .collect::>(); let mut cast_votes = HashSet::new(); @@ -85,12 +85,12 @@ impl AlonzoBabbageVoting { let votes: Vec<_> = proposals .iter() .filter(|&(_, v)| v == parameter_update) - .map(|(k, _)| k.clone()) + .map(|(k, _)| *k) .collect(); for v in &votes { // TODO Check keys (whether they are genesis keys) - cast_votes.insert(v.clone()); + cast_votes.insert(*v); } let votes_len = votes.len() as u32; @@ -168,8 +168,7 @@ mod tests { }; for prop in proposals { - let decoded_updates = - prop.1.iter().map(|(k, v)| (k.0.clone(), v.clone())).collect(); + let decoded_updates = prop.1.iter().map(|(k, v)| (k.0, v.clone())).collect(); let update_prop = AlonzoBabbageUpdateProposal { proposals: decoded_updates, diff --git a/modules/governance_state/src/conway_voting_test.rs b/modules/governance_state/src/conway_voting_test.rs index eb070bdc..67868fff 100644 --- a/modules/governance_state/src/conway_voting_test.rs +++ b/modules/governance_state/src/conway_voting_test.rs @@ -99,7 +99,7 @@ mod tests { *epoch, HashMap::from_iter(distr.iter().map(|PoolRecord(id, active, live)| { ( - id.clone(), + *id, DelegatedStake { active: *active, active_delegators_count: 0, diff --git a/modules/historical_accounts_state/src/immutable_historical_account_store.rs b/modules/historical_accounts_state/src/immutable_historical_account_store.rs index 74fa0f5b..7951cadc 100644 --- a/modules/historical_accounts_state/src/immutable_historical_account_store.rs +++ b/modules/historical_accounts_state/src/immutable_historical_account_store.rs @@ -326,7 +326,7 @@ impl ImmutableHistoricalAccountStore { fn make_epoch_key(account: &StakeAddress, epoch: u32) -> [u8; 32] { let mut key = [0u8; 32]; - key[..28].copy_from_slice(&account.get_credential().get_hash().as_ref()); + key[..28].copy_from_slice(account.get_credential().get_hash().as_ref()); key[28..32].copy_from_slice(&epoch.to_be_bytes()); key } diff --git a/modules/historical_accounts_state/src/state.rs b/modules/historical_accounts_state/src/state.rs index ea8f63dc..6700d606 100644 --- a/modules/historical_accounts_state/src/state.rs +++ b/modules/historical_accounts_state/src/state.rs @@ -117,7 +117,7 @@ impl State { let update = AccountReward { epoch: reward_epoch, amount: reward.delta, - pool: reward.pool.clone(), + pool: reward.pool, reward_type: reward.reward_type.clone(), }; entry.reward_history.get_or_insert_with(Vec::new).push(update); @@ -376,7 +376,7 @@ impl State { active_epoch: epoch.saturating_add(2), tx_identifier: *tx_identifier, amount: 0, // Amount is set during persistence when active stake is known - pool: pool.clone(), + pool: *pool, }; entry.delegation_history.get_or_insert_with(Vec::new).push(update); } diff --git a/modules/rest_blockfrost/src/handlers/pools.rs b/modules/rest_blockfrost/src/handlers/pools.rs index 8d402c40..07f35a47 100644 --- a/modules/rest_blockfrost/src/handlers/pools.rs +++ b/modules/rest_blockfrost/src/handlers/pools.rs @@ -201,10 +201,8 @@ async fn handle_pools_extended_blockfrost( }; // Populate pools_operators - let pools_operators = pools_list_with_info - .iter() - .map(|(pool_operator, _)| pool_operator.clone()) - .collect::>(); + let pools_operators = + pools_list_with_info.iter().map(|(pool_operator, _)| *pool_operator).collect::>(); // Get an active stake for each pool from spo-state let pools_active_stakes_msg = Arc::new(Message::StateQuery(StateQuery::Pools( @@ -423,7 +421,7 @@ async fn handle_pools_spo_blockfrost( // Get PoolRegistration from spo state let pool_info_msg = Arc::new(Message::StateQuery(StateQuery::Pools( PoolsStateQuery::GetPoolInfo { - pool_id: pool_operator.clone(), + pool_id: pool_operator, }, ))); @@ -472,9 +470,7 @@ async fn handle_pools_spo_blockfrost( // query live stakes from accounts_state let live_stakes_info_msg = Arc::new(Message::StateQuery(StateQuery::Accounts( - AccountsStateQuery::GetPoolLiveStake { - pool_operator: pool_operator.clone(), - }, + AccountsStateQuery::GetPoolLiveStake { pool_operator }, ))); let live_stakes_info_f = query_state( &context, @@ -507,7 +503,7 @@ async fn handle_pools_spo_blockfrost( // Query pool update events from spo_state let pool_updates_msg = Arc::new(Message::StateQuery(StateQuery::Pools( PoolsStateQuery::GetPoolUpdates { - pool_id: pool_operator.clone(), + pool_id: pool_operator, }, ))); let pool_updates_f = query_state( @@ -531,7 +527,7 @@ async fn handle_pools_spo_blockfrost( // Query total_blocks_minted from spo_state let total_blocks_minted_msg = Arc::new(Message::StateQuery(StateQuery::Pools( PoolsStateQuery::GetPoolTotalBlocksMinted { - pool_id: pool_operator.clone(), + pool_id: pool_operator, }, ))); let total_blocks_minted_f = query_state( @@ -600,7 +596,7 @@ async fn handle_pools_spo_blockfrost( // Query blocks_minted from epochs_state let epoch_blocks_minted_msg = Arc::new(Message::StateQuery(StateQuery::Epochs( EpochsStateQuery::GetLatestEpochBlocksMintedByPool { - spo_id: pool_info.operator.clone(), + spo_id: pool_info.operator, }, ))); let epoch_blocks_minted_f = query_state( @@ -618,7 +614,7 @@ async fn handle_pools_spo_blockfrost( // query active stakes info from spo_state let active_stakes_info_msg = Arc::new(Message::StateQuery(StateQuery::Pools( PoolsStateQuery::GetPoolActiveStakeInfo { - pool_operator: pool_operator.clone(), + pool_operator, epoch: latest_epoch, }, ))); @@ -808,9 +804,7 @@ pub async fn handle_pool_metadata_blockfrost( }; let pool_metadata_msg = Arc::new(Message::StateQuery(StateQuery::Pools( - PoolsStateQuery::GetPoolMetadata { - pool_id: spo.clone(), - }, + PoolsStateQuery::GetPoolMetadata { pool_id: spo }, ))); let pool_metadata = query_state( &context, @@ -889,9 +883,7 @@ pub async fn handle_pool_relays_blockfrost( }; let pool_relay_msg = Arc::new(Message::StateQuery(StateQuery::Pools( - PoolsStateQuery::GetPoolRelays { - pool_id: spo.clone(), - }, + PoolsStateQuery::GetPoolRelays { pool_id: spo }, ))); let pool_relays = query_state( @@ -944,9 +936,7 @@ pub async fn handle_pool_delegators_blockfrost( // Get Pool delegators from spo-state let pool_delegators_msg = Arc::new(Message::StateQuery(StateQuery::Pools( - PoolsStateQuery::GetPoolDelegators { - pool_id: spo.clone(), - }, + PoolsStateQuery::GetPoolDelegators { pool_id: spo }, ))); let pool_delegators = query_state( @@ -978,9 +968,7 @@ pub async fn handle_pool_delegators_blockfrost( None => { // Query from Accounts state let pool_delegators_msg = Arc::new(Message::StateQuery(StateQuery::Accounts( - AccountsStateQuery::GetPoolDelegators { - pool_operator: spo.clone(), - }, + AccountsStateQuery::GetPoolDelegators { pool_operator: spo }, ))); let pool_delegators = query_state( &context, @@ -1005,7 +993,7 @@ pub async fn handle_pool_delegators_blockfrost( let mut delegators_rest = Vec::::new(); for (d, l) in pool_delegators { - let bech32 = StakeCredential::AddrKeyHash(d.clone()) + let bech32 = StakeCredential::AddrKeyHash(d) .to_stake_bech32() .map_err(|e| anyhow::anyhow!("Invalid stake address in pool delegators: {e}"))?; delegators_rest.push(PoolDelegatorRest { @@ -1041,9 +1029,7 @@ pub async fn handle_pool_blocks_blockfrost( // Get blocks by pool_id from spo_state let pool_blocks_msg = Arc::new(Message::StateQuery(StateQuery::Pools( - PoolsStateQuery::GetBlocksByPool { - pool_id: spo.clone(), - }, + PoolsStateQuery::GetBlocksByPool { pool_id: spo }, ))); let pool_blocks = query_state( @@ -1093,9 +1079,7 @@ pub async fn handle_pool_updates_blockfrost( // query from spo_state let pool_updates_msg = Arc::new(Message::StateQuery(StateQuery::Pools( - PoolsStateQuery::GetPoolUpdates { - pool_id: spo.clone(), - }, + PoolsStateQuery::GetPoolUpdates { pool_id: spo }, ))); let pool_updates = query_state( &context, @@ -1153,9 +1137,7 @@ pub async fn handle_pool_votes_blockfrost( // query from spo_state let pool_votes_msg = Arc::new(Message::StateQuery(StateQuery::Pools( - PoolsStateQuery::GetPoolVotes { - pool_id: spo.clone(), - }, + PoolsStateQuery::GetPoolVotes { pool_id: spo }, ))); let pool_votes = query_state( &context, diff --git a/modules/spdd_state/src/spdd_state.rs b/modules/spdd_state/src/spdd_state.rs index 3c8194ae..97848468 100644 --- a/modules/spdd_state/src/spdd_state.rs +++ b/modules/spdd_state/src/spdd_state.rs @@ -75,7 +75,7 @@ impl SPDDState { guard.apply_spdd_snapshot( msg.epoch, - msg.spos.iter().map(|(k, v)| (k.clone(), *v)), + msg.spos.iter().map(|(k, v)| (*k, *v)), ); } .instrument(span) diff --git a/modules/spdd_state/src/state.rs b/modules/spdd_state/src/state.rs index 80bf570e..2080dfaf 100644 --- a/modules/spdd_state/src/state.rs +++ b/modules/spdd_state/src/state.rs @@ -29,7 +29,7 @@ impl State { None => true, }; if changed { - next.insert(k.clone(), v_new); + next.insert(k, v_new); } present.insert(k); } diff --git a/modules/spo_state/src/epochs_history.rs b/modules/spo_state/src/epochs_history.rs index bc57b506..6120ff77 100644 --- a/modules/spo_state/src/epochs_history.rs +++ b/modules/spo_state/src/epochs_history.rs @@ -187,7 +187,7 @@ impl EpochsHistoryState { epoch: u64, update_fn: impl FnOnce(&mut EpochState), ) { - let mut epochs = epochs_history.entry(spo.clone()).or_default(); + let mut epochs = epochs_history.entry(*spo).or_default(); let epoch_state = epochs.entry(epoch).or_insert_with(|| EpochState::new(epoch)); update_fn(epoch_state); } @@ -242,7 +242,7 @@ mod tests { epoch_activity_msg.spo_blocks = vec![(spo_block_key_hash, 1)]; epoch_activity_msg.total_blocks = 1; epoch_activity_msg.total_fees = 10; - epochs_history.handle_epoch_activity(&block, &epoch_activity_msg, &vec![(pool_id, 1)]); + epochs_history.handle_epoch_activity(&block, &epoch_activity_msg, &[(pool_id, 1)]); let mut spo_rewards_msg = new_spo_rewards_message(1); spo_rewards_msg.spos = vec![( diff --git a/modules/spo_state/src/retired_pools_history.rs b/modules/spo_state/src/retired_pools_history.rs index 37648cc1..539d702b 100644 --- a/modules/spo_state/src/retired_pools_history.rs +++ b/modules/spo_state/src/retired_pools_history.rs @@ -40,7 +40,7 @@ impl RetiredPoolsHistoryState { .value() .iter() .map(move |pool| PoolRetirement { - operator: pool.clone(), + operator: *pool, epoch, }) .collect::>() diff --git a/modules/spo_state/src/spo_state.rs b/modules/spo_state/src/spo_state.rs index f157ca00..5ae1b45d 100644 --- a/modules/spo_state/src/spo_state.rs +++ b/modules/spo_state/src/spo_state.rs @@ -287,7 +287,7 @@ impl SPOState { let spos: Vec<(PoolId, usize)> = epoch_activity_message .spo_blocks .iter() - .map(|(hash, count)| (hash.clone(), *count)) + .map(|(hash, count)| (*hash, *count)) .collect(); epochs_history.handle_epoch_activity( block_info, diff --git a/modules/spo_state/src/state.rs b/modules/spo_state/src/state.rs index 94b5ca4f..bb849525 100644 --- a/modules/spo_state/src/state.rs +++ b/modules/spo_state/src/state.rs @@ -120,11 +120,11 @@ impl From for State { impl From<&State> for SPOState { fn from(state: &State) -> Self { Self { - pools: state.spos.iter().map(|(key, value)| (key.clone(), value.clone())).collect(), + pools: state.spos.iter().map(|(key, value)| (*key, value.clone())).collect(), updates: state .pending_updates .iter() - .map(|(key, value)| (key.clone(), value.clone())) + .map(|(key, value)| (*key, value.clone())) .collect(), retiring: state .pending_deregistrations @@ -132,7 +132,7 @@ impl From<&State> for SPOState { .flat_map(|(epoch, key_hashes)| { key_hashes .iter() - .map(|key_hash| (key_hash.clone(), *epoch)) + .map(|key_hash| (*key_hash, *epoch)) .collect::>() }) .collect(), @@ -166,7 +166,7 @@ impl State { /// Get all Stake Pool Operators' operator hashes and their registration information pub fn list_pools_with_info(&self) -> Vec<(PoolId, PoolRegistration)> { - self.spos.iter().map(|(k, v)| (k.clone(), v.clone())).collect() + self.spos.iter().map(|(k, v)| (*k, v.clone())).collect() } /// Get pool metadata @@ -225,7 +225,7 @@ impl State { .filter(|(&epoch, _)| epoch > current_epoch) .flat_map(|(&epoch, retiring_operators)| { retiring_operators.iter().map(move |operator| PoolRetirement { - operator: operator.clone(), + operator: *operator, epoch, }) }) @@ -252,7 +252,7 @@ impl State { return false; } - *(self.total_blocks_minted.entry(pool_id.clone()).or_insert(0)) += 1; + *(self.total_blocks_minted.entry(pool_id).or_insert(0)) += 1; // if store_blocks is enabled if self.is_historical_blocks_enabled() { if let Some(historical_spos) = self.historical_spos.as_mut() { @@ -274,7 +274,7 @@ impl State { // Update any pending for (operator, reg) in &self.pending_updates { - self.spos.insert(operator.clone(), reg.clone()); + self.spos.insert(*operator, reg.clone()); } self.pending_updates.clear(); @@ -283,14 +283,14 @@ impl State { let deregistrations = self.pending_deregistrations.remove(&self.epoch); if let Some(deregistrations) = deregistrations { for dr in deregistrations { - debug!("Retiring SPO {}", hex::encode(&dr)); + debug!("Retiring SPO {}", hex::encode(dr)); match self.spos.remove(&dr) { None => error!( "Retirement requested for unregistered SPO {}", - hex::encode(&dr), + hex::encode(dr), ), Some(_de_reg) => { - retired_spos.push(dr.clone()); + retired_spos.push(dr); } }; } @@ -318,19 +318,19 @@ impl State { epoch = self.epoch, block = block.number, "New pending SPO update {} {:?}", - hex::encode(®.operator), + hex::encode(reg.operator), reg ); - self.pending_updates.insert(reg.operator.clone(), reg.clone()); + self.pending_updates.insert(reg.operator, reg.clone()); } else { debug!( epoch = self.epoch, block = block.number, "Registering SPO {} {:?}", - hex::encode(®.operator), + hex::encode(reg.operator), reg ); - self.spos.insert(reg.operator.clone(), reg.clone()); + self.spos.insert(reg.operator, reg.clone()); } // Remove any existing queued deregistrations @@ -340,7 +340,7 @@ impl State { if deregistrations.len() != old_len { debug!( "Removed pending deregistration of SPO {} from epoch {}", - hex::encode(®.operator), + hex::encode(reg.operator), epoch ); } @@ -351,7 +351,7 @@ impl State { // Don't check there was registration already or not // because we don't remove registration when pool is retired. let historical_spo = historical_spos - .entry(reg.operator.clone()) + .entry(reg.operator) .or_insert_with(|| HistoricalSPOState::new(&self.store_config)); historical_spo.add_pool_registration(reg); historical_spo @@ -368,7 +368,7 @@ impl State { ) { debug!( "SPO {} wants to retire at the end of epoch {} (cert in block number {})", - hex::encode(&ret.operator), + hex::encode(ret.operator), ret.epoch, block.number ); @@ -376,13 +376,13 @@ impl State { error!( "SPO retirement received for current or past epoch {} for SPO {}", ret.epoch, - hex::encode(&ret.operator) + hex::encode(ret.operator) ); } else if ret.epoch > self.epoch + TECHNICAL_PARAMETER_POOL_RETIRE_MAX_EPOCH { error!( "SPO retirement received for epoch {} that exceeds future limit for SPO {}", ret.epoch, - hex::encode(&ret.operator) + hex::encode(ret.operator) ); } else { // Replace any existing queued deregistrations @@ -392,12 +392,12 @@ impl State { if deregistrations.len() != old_len { debug!( "Replaced pending deregistration of SPO {} from epoch {}", - hex::encode(&ret.operator), + hex::encode(ret.operator), epoch ); } } - self.pending_deregistrations.entry(ret.epoch).or_default().push(ret.operator.clone()); + self.pending_deregistrations.entry(ret.epoch).or_default().push(ret.operator); // Note: not removing pending updates - the deregistation may happen many // epochs later than the update, and we apply updates before deregistrations @@ -412,7 +412,7 @@ impl State { } else { error!( "Historical SPO for {} not registered when try to retire it", - hex::encode(&ret.operator) + hex::encode(ret.operator) ); } } @@ -431,7 +431,7 @@ impl State { return; }; let mut stake_addresses = stake_addresses.lock().unwrap(); - let old_spo = stake_addresses.get(stake_address).and_then(|s| s.delegated_spo.clone()); + let old_spo = stake_addresses.get(stake_address).and_then(|s| s.delegated_spo); if stake_addresses.deregister_stake_address(stake_address) { // update historical_spos @@ -461,7 +461,7 @@ impl State { return; }; let mut stake_addresses = stake_addresses.lock().unwrap(); - let old_spo = stake_addresses.get(stake_address).and_then(|s| s.delegated_spo.clone()); + let old_spo = stake_addresses.get(stake_address).and_then(|s| s.delegated_spo); if stake_addresses.record_stake_delegation(stake_address, spo) { // update historical_spos @@ -488,7 +488,7 @@ impl State { // get old one or create from store_config let historical_spo = historical_spos - .entry(spo.clone()) + .entry(*spo) .or_insert_with(|| HistoricalSPOState::new(&self.store_config)); if let Some(added) = historical_spo.add_delegator(stake_address) { if !added { @@ -594,7 +594,7 @@ impl State { }; let historical_spo = historical_spos - .entry(spo.clone()) + .entry(*spo) .or_insert_with(|| HistoricalSPOState::new(&self.store_config)); if let Some(votes) = historical_spo.votes.as_mut() { @@ -689,7 +689,7 @@ mod tests { ) -> PoolRegistration { PoolRegistration { operator, - vrf_key_hash: vrf_key_hash.unwrap_or_else(|| VrfKeyHash::default()), + vrf_key_hash: vrf_key_hash.unwrap_or_default(), pledge: 0, cost: 0, margin: Ratio { @@ -738,7 +738,7 @@ mod tests { assert!(state.handle_tx_certs(&block, &msg).is_ok()); assert_eq!(1, state.spos.len()); let spo = state.spos.get(&pool_id); - assert!(!spo.is_none()); + assert!(spo.is_some()); } #[tokio::test] @@ -1004,7 +1004,7 @@ mod tests { let spo_id = test_pool_id_from_bytes(&[1]); msg.certificates.push(TxCertificateWithPos { - cert: TxCertificate::PoolRegistration(default_pool_registration(spo_id.clone(), None)), + cert: TxCertificate::PoolRegistration(default_pool_registration(spo_id, None)), tx_identifier: TxIdentifier::default(), cert_index: 0, }); @@ -1040,14 +1040,14 @@ mod tests { let mut msg = new_certs_msg(); let spo_id = test_pool_id_from_bytes(&[1]); msg.certificates.push(TxCertificateWithPos { - cert: TxCertificate::PoolRegistration(default_pool_registration(spo_id.clone(), None)), + cert: TxCertificate::PoolRegistration(default_pool_registration(spo_id, None)), tx_identifier: TxIdentifier::default(), cert_index: 0, }); let spo_id = test_pool_id_from_bytes(&[1]); msg.certificates.push(TxCertificateWithPos { - cert: TxCertificate::PoolRegistration(default_pool_registration(spo_id.clone(), None)), + cert: TxCertificate::PoolRegistration(default_pool_registration(spo_id, None)), tx_identifier: TxIdentifier::default(), cert_index: 0, }); diff --git a/modules/stake_delta_filter/src/utils.rs b/modules/stake_delta_filter/src/utils.rs index e920d159..22fae1c2 100644 --- a/modules/stake_delta_filter/src/utils.rs +++ b/modules/stake_delta_filter/src/utils.rs @@ -345,12 +345,12 @@ pub fn process_message( // Base addresses (stake delegated to itself) ShelleyAddressDelegationPart::StakeKeyHash(keyhash) => StakeAddress { network: shelley.network.clone(), - credential: StakeCredential::AddrKeyHash(keyhash.clone()), + credential: StakeCredential::AddrKeyHash(*keyhash), }, ShelleyAddressDelegationPart::ScriptHash(scripthash) => StakeAddress { network: shelley.network.clone(), - credential: StakeCredential::ScriptHash(scripthash.clone()), + credential: StakeCredential::ScriptHash(*scripthash), }, // Shelley addresses (stake delegated to some different address) diff --git a/processes/replayer/src/recorder_alonzo_governance.rs b/processes/replayer/src/recorder_alonzo_governance.rs index 8d7f7181..538b352a 100644 --- a/processes/replayer/src/recorder_alonzo_governance.rs +++ b/processes/replayer/src/recorder_alonzo_governance.rs @@ -55,7 +55,7 @@ impl BlockRecorder { for vote in votes.iter() { let mut votes_indexed = Vec::new(); for (h, u) in &vote.proposals { - votes_indexed.push(VoteRecord(ReplayerGenesisKeyhash(h.clone()), u.clone())); + votes_indexed.push(VoteRecord(ReplayerGenesisKeyhash(*h), u.clone())); } proposals.push((vote.enactment_epoch, votes_indexed)); }