Remove Copy from Secp256k1PrivateKey, Secp256k1PublicKey, StacksAddress, VerifyVoteArgs, and VoteInfo

clarity/src/vm/costs/mod.rs

@@ -949,7 +949,7 @@ impl TrackerData {
             if cost_function_ref.contract_id == boot_costs_id {
                 m.insert(
                     f,
-                    ClarityCostFunctionEvaluator::Default(cost_function_ref, *f, v),
+                    ClarityCostFunctionEvaluator::Default(cost_function_ref, f.clone(), v),
                 );
             } else {
                 m.insert(f, ClarityCostFunctionEvaluator::Clarity(cost_function_ref));

clarity/src/vm/mod.rs

@@ -280,7 +280,7 @@ pub fn apply(
         env.call_stack.insert(&identifier, track_recursion);
         let mut resp = match function {
             CallableType::NativeFunction(_, function, cost_function) => {
-                runtime_cost(*cost_function, env, evaluated_args.len())
+                runtime_cost(cost_function.clone(), env, evaluated_args.len())
                     .map_err(Error::from)
                     .and_then(|_| function.apply(evaluated_args, env))
             }
@@ -290,7 +290,7 @@ pub fn apply(
                 } else {
                     evaluated_args.len() as u64
                 };
-                runtime_cost(*cost_function, env, cost_input)
+                runtime_cost(cost_function.clone(), env, cost_input)
                     .map_err(Error::from)
                     .and_then(|_| function.apply(evaluated_args, env))
             }

libsigner/src/signer_set.rs

@@ -67,12 +67,12 @@ impl SignerEntries {
                 })?;
 
             let stacks_address = StacksAddress::p2pkh(is_mainnet, &signer_public_key);
-            signer_addr_to_id.insert(stacks_address, signer_id);
-            signer_id_to_pk.insert(signer_id, signer_public_key);
-            signer_pk_to_id.insert(signer_public_key, signer_id);
+            signer_addr_to_id.insert(stacks_address.clone(), signer_id);
+            signer_id_to_pk.insert(signer_id, signer_public_key.clone());
+            signer_pk_to_id.insert(signer_public_key.clone(), signer_id);
             signer_pks.push(signer_public_key);
-            signer_id_to_addr.insert(signer_id, stacks_address);
-            signer_addr_to_weight.insert(stacks_address, entry.weight);
+            signer_id_to_addr.insert(signer_id, stacks_address.clone());
+            signer_addr_to_weight.insert(stacks_address.clone(), entry.weight);
             signer_addresses.push(stacks_address);
         }
 

libsigner/src/tests/signer_state.rs

@@ -53,7 +53,7 @@ fn generate_global_state_evaluator(num_addresses: u32) -> GlobalStateEvaluator {
 
     let mut address_updates = HashMap::new();
     for address in address_weights.keys() {
-        address_updates.insert(*address, update.clone());
+        address_updates.insert(address.clone(), update.clone());
     }
     GlobalStateEvaluator::new(address_updates, address_weights)
 }
@@ -72,7 +72,7 @@ fn determine_latest_supported_signer_protocol_versions() {
     let mut global_eval = generate_global_state_evaluator(5);
 
     let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
-    let local_address = addresses[0];
+    let local_address = addresses[0].clone();
 
     let local_update = global_eval
         .address_updates
@@ -152,7 +152,7 @@ fn determine_global_burn_views() {
     let mut global_eval = generate_global_state_evaluator(5);
 
     let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
-    let local_address = addresses[0];
+    let local_address = addresses[0].clone();
     let local_update = global_eval
         .address_updates
         .get(&local_address)
@@ -211,7 +211,7 @@ fn determine_global_states() {
     let mut global_eval = generate_global_state_evaluator(5);
 
     let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
-    let local_address = addresses[0];
+    let local_address = addresses[0].clone();
     let local_update = global_eval
         .address_updates
         .get(&local_address)
@@ -240,7 +240,7 @@ fn determine_global_states() {
         tx_replay_set: ReplayTransactionSet::none(),
     };
 
-    global_eval.insert_update(local_address, local_update);
+    global_eval.insert_update(local_address.clone(), local_update);
     assert_eq!(global_eval.determine_global_state().unwrap(), state_machine);
     let new_miner = StateMachineUpdateMinerState::ActiveMiner {
         current_miner_pkh: Hash160([0x00; 20]),
@@ -289,7 +289,7 @@ fn determine_global_states_with_tx_replay_set() {
     let mut global_eval = generate_global_state_evaluator(5);
 
     let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
-    let local_address = addresses[0];
+    let local_address = addresses[0].clone();
     let local_update = global_eval
         .address_updates
         .get(&local_address)
@@ -337,7 +337,7 @@ fn determine_global_states_with_tx_replay_set() {
 
     // Let's update 3 signers to some new tx_replay_set but one that has no txs in it
     for address in addresses.iter().skip(1).take(3) {
-        global_eval.insert_update(*address, no_tx_replay_set_update.clone());
+        global_eval.insert_update(address.clone(), no_tx_replay_set_update.clone());
     }
 
     // we have disagreement about the burn block height
@@ -346,7 +346,7 @@ fn determine_global_states_with_tx_replay_set() {
         "We should have disagreement about the burn view"
     );
 
-    global_eval.insert_update(local_address, no_tx_replay_set_update.clone());
+    global_eval.insert_update(local_address.clone(), no_tx_replay_set_update.clone());
 
     let new_burn_view_state_machine = SignerStateMachine {
         burn_block,
@@ -357,7 +357,7 @@ fn determine_global_states_with_tx_replay_set() {
     };
 
     // Let's tip the scales over to the correct burn view
-    global_eval.insert_update(local_address, no_tx_replay_set_update);
+    global_eval.insert_update(local_address.clone(), no_tx_replay_set_update);
     assert_eq!(
         global_eval.determine_global_state().unwrap(),
         new_burn_view_state_machine
@@ -372,7 +372,7 @@ fn determine_global_states_with_tx_replay_set() {
         post_condition_mode: TransactionPostConditionMode::Allow,
         post_conditions: vec![],
         payload: TransactionPayload::TokenTransfer(
-            local_address.into(),
+            local_address.clone().into(),
             123,
             TokenTransferMemo([0u8; 34]),
         ),

stacks-common/src/types/chainstate.rs

@@ -286,7 +286,7 @@ impl fmt::Display for PoxId {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Copy, Serialize, Deserialize, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub struct StacksAddress {
     version: u8,
     bytes: Hash160,

stacks-common/src/util/macros.rs

@@ -50,7 +50,7 @@ macro_rules! define_named_enum {
         }
     ) => {
         $(#[$enum_meta])*
-        #[derive(::serde::Serialize, ::serde::Deserialize, Debug, Hash, PartialEq, Eq, Copy, Clone)]
+        #[derive(::serde::Serialize, ::serde::Deserialize, Debug, Hash, PartialEq, Eq, Clone)]
         pub enum $Name {
             $(
                 $(#[$variant_meta])*

stacks-common/src/util/secp256k1/native.rs

@@ -34,7 +34,7 @@ use crate::util::hash::{hex_bytes, to_hex, Sha256Sum};
 // per-thread Secp256k1 context
 thread_local!(static _secp256k1: Secp256k1<secp256k1::All> = Secp256k1::new());
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, Hash)]
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize, Hash)]
 pub struct Secp256k1PublicKey {
     // serde is broken for secp256k1, so do it ourselves
     #[serde(
@@ -45,7 +45,7 @@ pub struct Secp256k1PublicKey {
     compressed: bool,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
 pub struct Secp256k1PrivateKey {
     // serde is broken for secp256k1, so do it ourselves
     #[serde(
@@ -468,7 +468,7 @@ mod tests {
             .unwrap()
             .compress_public());
 
-        assert_eq!(Secp256k1PrivateKey::from_hex(&h_uncomp), Ok(t1));
+        assert_eq!(Secp256k1PrivateKey::from_hex(&h_uncomp), Ok(t1.clone()));
 
         t1.set_compress_public(true);
 

stacks-node/src/burnchains/bitcoin_regtest_controller.rs

@@ -629,11 +629,11 @@ impl BitcoinRegtestController {
         let filter_addresses = vec![addr2str(&address)];
 
         let pubk = if self.config.miner.segwit {
-            let mut p = *public_key;
+            let mut p = public_key.clone();
             p.set_compressed(true);
             p
         } else {
-            *public_key
+            public_key.clone()
         };
 
         test_debug!("Import public key '{}'", &pubk.to_hex());
@@ -736,11 +736,11 @@ impl BitcoinRegtestController {
         block_height: u64,
     ) -> Option<UTXOSet> {
         let pubk = if self.config.miner.segwit && epoch_id >= StacksEpochId::Epoch21 {
-            let mut p = *public_key;
+            let mut p = public_key.clone();
             p.set_compressed(true);
             p
         } else {
-            *public_key
+            public_key.clone()
         };
 
         // Configure UTXO filter

stacks-node/src/keychain.rs

@@ -354,7 +354,7 @@ mod tests {
                 }
             };
             sk.set_compress_public(true);
-            self.microblocks_secret_keys.push(sk);
+            self.microblocks_secret_keys.push(sk.clone());
 
             debug!("Microblock keypair rotated";
                    "burn_block_height" => %burn_block_height,
@@ -451,7 +451,7 @@ mod tests {
         }
 
         pub fn generate_op_signer(&self) -> BurnchainOpSigner {
-            BurnchainOpSigner::new(self.secret_keys[0])
+            BurnchainOpSigner::new(self.secret_keys[0].clone())
         }
     }
 
@@ -536,7 +536,7 @@ mod tests {
                 TransactionVersion::Testnet,
                 k1.get_transaction_auth().unwrap(),
                 TransactionPayload::TokenTransfer(
-                    recv_addr.into(),
+                    recv_addr.clone().into(),
                     123,
                     TokenTransferMemo([0u8; 34]),
                 ),

stacks-node/src/nakamoto_node.rs

@@ -186,7 +186,7 @@ impl StacksNode {
         let burnchain = runloop.get_burnchain();
         let atlas_config = config.atlas.clone();
         let mut keychain = Keychain::default(config.node.seed.clone());
-        if let Some(mining_key) = config.miner.mining_key {
+        if let Some(mining_key) = config.miner.mining_key.clone() {
             keychain.set_nakamoto_sk(mining_key);
         }
 

stacks-node/src/nakamoto_node/miner.rs

@@ -466,7 +466,7 @@ impl BlockMinerThread {
         let mut last_block_rejected = false;
 
         let reward_set = self.load_signer_set()?;
-        let Some(miner_privkey) = self.config.miner.mining_key else {
+        let Some(miner_privkey) = self.config.miner.mining_key.clone() else {
             return Err(NakamotoNodeError::MinerConfigurationFailed(
                 "No mining key configured, cannot mine",
             ));

stacks-node/src/operations.rs

@@ -116,7 +116,7 @@ impl BurnchainOpSigner {
     /// This is useful in testing scenarios where you need a fresh, undisposed copy
     /// of a signer without recreating the private key.
     pub fn undisposed(&self) -> Self {
-        Self::new(self.secret_key)
+        Self::new(self.secret_key.clone())
     }
 }
 

stacks-node/src/tests/epoch_205.rs

@@ -689,7 +689,7 @@ fn test_cost_limit_switch_version205() {
     // Create three characters, `creator`, `alice` and `bob`.
     let creator_sk = StacksPrivateKey::random();
     let creator_addr = to_addr(&creator_sk);
-    let creator_pd: PrincipalData = creator_addr.into();
+    let creator_pd: PrincipalData = creator_addr.clone().into();
 
     let alice_sk = StacksPrivateKey::random();
     let alice_addr = to_addr(&alice_sk);

stacks-node/src/tests/epoch_21.rs

@@ -543,7 +543,7 @@ fn transition_fixes_bitcoin_rigidity() {
 
     let spender_sk = StacksPrivateKey::from_hex(SK_1).unwrap();
     let spender_stx_addr: StacksAddress = to_addr(&spender_sk);
-    let spender_addr: PrincipalData = spender_stx_addr.into();
+    let spender_addr: PrincipalData = spender_stx_addr.clone().into();
     let _spender_btc_addr = BitcoinAddress::from_bytes_legacy(
         BitcoinNetworkType::Regtest,
         LegacyBitcoinAddressType::PublicKeyHash,
@@ -553,7 +553,7 @@ fn transition_fixes_bitcoin_rigidity() {
 
     let spender_2_sk = StacksPrivateKey::from_hex(SK_2).unwrap();
     let spender_2_stx_addr: StacksAddress = to_addr(&spender_2_sk);
-    let spender_2_addr: PrincipalData = spender_2_stx_addr.into();
+    let spender_2_addr: PrincipalData = spender_2_stx_addr.clone().into();
 
     let epoch_2_05 = 210;
     let epoch_2_1 = 215;
@@ -654,7 +654,7 @@ fn transition_fixes_bitcoin_rigidity() {
 
     // okay, let's send a pre-stx op for a transfer-stx op that will get mined before the 2.1 epoch
     let pre_stx_op = PreStxOp {
-        output: spender_stx_addr,
+        output: spender_stx_addr.clone(),
         // to be filled in
         txid: Txid([0u8; 32]),
         vtxindex: 0,
@@ -685,8 +685,8 @@ fn transition_fixes_bitcoin_rigidity() {
     let recipient_sk = StacksPrivateKey::random();
     let recipient_addr = to_addr(&recipient_sk);
     let transfer_stx_op = TransferStxOp {
-        sender: spender_stx_addr,
-        recipient: recipient_addr,
+        sender: spender_stx_addr.clone(),
+        recipient: recipient_addr.clone(),
         transfered_ustx: 100_000,
         memo: vec![],
         // to be filled in
@@ -696,7 +696,7 @@ fn transition_fixes_bitcoin_rigidity() {
         burn_header_hash: BurnchainHeaderHash([0u8; 32]),
     };
 
-    let mut spender_signer = BurnchainOpSigner::new(spender_sk);
+    let mut spender_signer = BurnchainOpSigner::new(spender_sk.clone());
 
     assert!(
         btc_regtest_controller
@@ -808,7 +808,7 @@ fn transition_fixes_bitcoin_rigidity() {
 
     // okay, let's send a pre-stx op.
     let pre_stx_op = PreStxOp {
-        output: spender_stx_addr,
+        output: spender_stx_addr.clone(),
         // to be filled in
         txid: Txid([0u8; 32]),
         vtxindex: 0,
@@ -835,8 +835,8 @@ fn transition_fixes_bitcoin_rigidity() {
     let recipient_sk = StacksPrivateKey::random();
     let recipient_addr = to_addr(&recipient_sk);
     let transfer_stx_op = TransferStxOp {
-        sender: spender_stx_addr,
-        recipient: recipient_addr,
+        sender: spender_stx_addr.clone(),
+        recipient: recipient_addr.clone(),
         transfered_ustx: 100_000,
         memo: vec![],
         // to be filled in
@@ -879,7 +879,7 @@ fn transition_fixes_bitcoin_rigidity() {
 
     // okay, let's send a pre-stx op.
     let pre_stx_op = PreStxOp {
-        output: spender_2_stx_addr,
+        output: spender_2_stx_addr.clone(),
         // to be filled in
         txid: Txid([0u8; 32]),
         vtxindex: 0,
@@ -908,8 +908,8 @@ fn transition_fixes_bitcoin_rigidity() {
 
     // let's fire off our transfer op.
     let transfer_stx_op = TransferStxOp {
-        sender: spender_2_stx_addr,
-        recipient: recipient_addr,
+        sender: spender_2_stx_addr.clone(),
+        recipient: recipient_addr.clone(),
         transfered_ustx: 100_000,
         memo: vec![],
         // to be filled in
@@ -919,7 +919,7 @@ fn transition_fixes_bitcoin_rigidity() {
         burn_header_hash: BurnchainHeaderHash([0u8; 32]),
     };
 
-    let mut spender_signer = BurnchainOpSigner::new(spender_2_sk);
+    let mut spender_signer = BurnchainOpSigner::new(spender_2_sk.clone());
 
     btc_regtest_controller
         .submit_manual(
@@ -974,8 +974,8 @@ fn transition_fixes_bitcoin_rigidity() {
     };
 
     let transfer_stx_op = TransferStxOp {
-        sender: spender_stx_addr,
-        recipient: recipient_addr,
+        sender: spender_stx_addr.clone(),
+        recipient: recipient_addr.clone(),
         transfered_ustx: 123,
         memo: vec![],
         // to be filled in
@@ -1082,7 +1082,7 @@ fn transition_adds_get_pox_addr_recipients() {
     .iter()
     .enumerate()
     {
-        let spender_sk = spender_sks[i];
+        let spender_sk = spender_sks[i].clone();
         let pox_addr_tuple = execute(
             &format!(
                 "{{ hashbytes: 0x{pox_pubkey_hash}, version: 0x{:02x} }}",

stacks-node/src/tests/epoch_23.rs

@@ -53,7 +53,7 @@ fn trait_invocation_behavior() {
     let spender_addr: PrincipalData = to_addr(&spender_sk).into();
 
     let impl_contract_id =
-        QualifiedContractIdentifier::new(contract_addr.into(), "impl-simple".into());
+        QualifiedContractIdentifier::new(contract_addr.clone().into(), "impl-simple".into());
 
     let mut spender_nonce = 0;
     let fee_amount = 10_000;