Merge branch 'develop' into ci/generate-tests

.github/workflows/bitcoin-tests.yml

@@ -121,7 +121,6 @@ jobs:
           - test-name: tests::epoch_23::trait_invocation_behavior
           - test-name: tests::epoch_24::fix_to_pox_contract
           - test-name: tests::epoch_24::verify_auto_unlock_behavior
-
     steps:
       ## Setup test environment
       - name: Setup Test Environment

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
+## [Unreleased]
+
+### Changed
+
+- Miner will include other transactions in blocks with tenure extend transactions (#5760)
+
 ## [3.1.0.0.4]
 
 ### Added

stacks-common/src/address/b58.rs

@@ -14,7 +14,7 @@
 
 //! Base58 encoder and decoder
 
-use std::{error, fmt, str};
+use std::{fmt, str};
 
 use crate::address::Error;
 use crate::util::hash::DoubleSha256;

stacks-common/src/address/mod.rs

@@ -19,7 +19,7 @@ use std::{error, fmt};
 use sha2::{Digest, Sha256};
 
 use crate::deps_common::bitcoin::blockdata::opcodes::All as btc_opcodes;
-use crate::deps_common::bitcoin::blockdata::script::{Builder, Instruction, Script};
+use crate::deps_common::bitcoin::blockdata::script::Builder;
 use crate::types::PublicKey;
 use crate::util::hash::Hash160;
 
@@ -220,7 +220,6 @@ pub fn public_keys_to_address_hash<K: PublicKey>(
 mod test {
     use super::*;
     use crate::util::hash::*;
-    use crate::util::log;
     use crate::util::secp256k1::Secp256k1PublicKey as PubKey;
 
     struct PubkeyFixture {

stacks-common/src/bitvec.rs

@@ -260,7 +260,6 @@ mod test {
 
     use super::BitVec;
     use crate::codec::StacksMessageCodec;
-    use crate::util::hash::to_hex;
 
     fn check_set_get(mut input: BitVec<{ u16::MAX }>) {
         let original_input = input.clone();

stacks-common/src/deps_common/bitcoin/blockdata/block.rs

@@ -25,7 +25,6 @@ use crate::deps_common::bitcoin::blockdata::transaction::Transaction;
 use crate::deps_common::bitcoin::network::constants::Network;
 use crate::deps_common::bitcoin::network::encodable::VarInt;
 use crate::deps_common::bitcoin::network::serialize::BitcoinHash;
-use crate::deps_common::bitcoin::util;
 use crate::deps_common::bitcoin::util::hash::Sha256dHash;
 use crate::deps_common::bitcoin::util::Error;
 use crate::deps_common::bitcoin::util::Error::{SpvBadProofOfWork, SpvBadTarget};

stacks-common/src/deps_common/bitcoin/blockdata/script.rs

@@ -27,7 +27,6 @@
 use std::mem::size_of;
 use std::{error, fmt};
 
-use serde;
 use sha2::{Digest, Sha256};
 
 use crate::deps_common::bitcoin::blockdata::opcodes;

stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs

@@ -34,7 +34,6 @@ use crate::deps_common::bitcoin::network::serialize::{
     self, serialize, BitcoinHash, SimpleDecoder, SimpleEncoder,
 };
 use crate::deps_common::bitcoin::util::hash::Sha256dHash;
-use crate::util::hash::to_hex;
 
 /// A reference to a transaction output
 #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
@@ -675,7 +674,7 @@ impl SigHashType {
 
 #[cfg(test)]
 mod tests {
-    use super::{SigHashType, Transaction, TxIn};
+    use super::{Transaction, TxIn};
     use crate::deps_common;
     use crate::deps_common::bitcoin::blockdata::script::Script;
     use crate::deps_common::bitcoin::network::serialize::{deserialize, BitcoinHash};
@@ -690,7 +689,6 @@ mod tests {
 
     #[test]
     fn test_is_coinbase() {
-        use crate::deps_common::bitcoin::blockdata::constants;
         use crate::deps_common::bitcoin::network::constants::Network;
 
         let genesis = deps_common::bitcoin::blockdata::constants::genesis_block(Network::Bitcoin);

stacks-common/src/deps_common/bitcoin/network/message_network.rs

@@ -19,8 +19,6 @@
 //!
 
 use crate::deps_common::bitcoin::network::address::Address;
-use crate::deps_common::bitcoin::network::constants;
-use crate::util;
 
 // Some simple messages
 

stacks-common/src/deps_common/bitcoin/util/hash.rs

@@ -18,7 +18,7 @@
 use std::char::from_digit;
 use std::cmp::min;
 use std::io::{Cursor, Write};
-use std::{error, fmt, mem};
+use std::{fmt, mem};
 
 use ripemd::Ripemd160;
 #[cfg(feature = "serde")]

stacks-common/src/deps_common/httparse/mod.rs

@@ -30,7 +30,7 @@
 //! Originally written by Sean McArthur.
 //!
 //! Modified by Jude Nelson to remove all unsafe code.
-use std::{error, fmt, mem, result, str};
+use std::{fmt, mem, result, str};
 
 macro_rules! next {
     ($bytes:ident) => {{
@@ -1282,8 +1282,6 @@ mod tests {
 
     #[test]
     fn test_std_error() {
-        use std::error::Error as StdError;
-
         use super::Error;
         let err = Error::HeaderName;
         assert_eq!(err.to_string(), err.description_str());

stacks-common/src/libcommon.rs

@@ -1,12 +1,12 @@
 #![allow(unused_macros)]
-#![allow(unused_imports)]
 #![allow(dead_code)]
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
 #![allow(non_upper_case_globals)]
 #![cfg_attr(test, allow(unused_variables, unused_assignments))]
 #![allow(clippy::assertions_on_constants)]
 
+#[allow(unused_imports)]
 #[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
 extern crate slog;
 
@@ -33,8 +33,6 @@ pub mod deps_common;
 
 pub mod bitvec;
 
-use crate::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksBlockId};
-
 pub mod consts {
     use crate::types::chainstate::{BlockHeaderHash, ConsensusHash};
     pub use crate::types::MINING_COMMITMENT_WINDOW;

stacks-common/src/types/chainstate.rs

@@ -14,24 +14,19 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::fmt::{self, Display};
+use std::fmt;
 use std::io::{Read, Write};
 use std::str::FromStr;
 
-use curve25519_dalek::digest::Digest;
-use rand::{Rng, SeedableRng};
-use serde::de::{Deserialize, Error as de_Error};
-use serde::ser::Error as ser_Error;
 use serde::Serialize;
-use sha2::{Digest as Sha2Digest, Sha256, Sha512_256};
+use sha2::{Digest as Sha2Digest, Sha512_256};
 
 use crate::address::Error as AddressError;
 use crate::codec::{read_next, write_next, Error as CodecError, StacksMessageCodec};
 use crate::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use crate::deps_common::bitcoin::util::hash::Sha256dHash;
-use crate::util::hash::{to_hex, DoubleSha256, Hash160, Sha512Trunc256Sum, HASH160_ENCODED_SIZE};
+use crate::util::hash::{Hash160, Sha512Trunc256Sum, HASH160_ENCODED_SIZE};
 use crate::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
-use crate::util::uint::Uint256;
 use crate::util::vrf::{VRFProof, VRF_PROOF_ENCODED_SIZE};
 
 pub type StacksPublicKey = Secp256k1PublicKey;
@@ -514,6 +509,8 @@ impl BurnchainHeaderHash {
         index_root: &TrieHash,
         noise: u64,
     ) -> BurnchainHeaderHash {
+        use crate::util::hash::DoubleSha256;
+
         let mut bytes = vec![];
         bytes.extend_from_slice(&block_height.to_be_bytes());
         bytes.extend_from_slice(index_root.as_bytes());

stacks-common/src/types/mod.rs

@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::cell::LazyCell;
 use std::cmp::Ordering;
 use std::fmt;
 use std::ops::{Deref, DerefMut, Index, IndexMut};
@@ -30,7 +29,6 @@ use crate::address::{
     C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
 use crate::consts::MICROSTACKS_PER_STACKS;
-use crate::deps_common::bitcoin::blockdata::transaction::TxOut;
 use crate::types::chainstate::{StacksAddress, StacksPublicKey};
 use crate::util::hash::Hash160;
 use crate::util::secp256k1::{MessageSignature, Secp256k1PublicKey};

stacks-common/src/util/chunked_encoding.rs

@@ -445,9 +445,10 @@ impl<W: Write> Write for HttpChunkedTransferWriter<'_, '_, W> {
     }
 }
 
+#[cfg(test)]
 mod test {
     use std::io;
-    use std::io::{Read, Write};
+    use std::io::Read;
 
     use rand::RngCore;
 

stacks-common/src/util/db.rs

@@ -17,7 +17,7 @@
 use std::backtrace::Backtrace;
 use std::sync::{LazyLock, Mutex};
 use std::thread;
-use std::time::{Duration, Instant};
+use std::time::Instant;
 
 use hashbrown::HashMap;
 use rand::{thread_rng, Rng};

stacks-common/src/util/hash.rs

@@ -20,7 +20,6 @@ use std::{fmt, mem};
 
 use ripemd::Ripemd160;
 use serde::de::{Deserialize, Error as de_Error};
-use serde::ser::Error as ser_Error;
 use serde::Serialize;
 use sha2::{Digest, Sha256, Sha512, Sha512_256};
 use sha3::Keccak256;
@@ -29,7 +28,7 @@ use crate::types::StacksPublicKeyBuffer;
 use crate::util::pair::*;
 use crate::util::secp256k1::Secp256k1PublicKey;
 use crate::util::uint::Uint256;
-use crate::util::{log, HexError};
+use crate::util::HexError;
 
 // hash function for Merkle trees
 pub trait MerkleHashFunc {
@@ -659,9 +658,7 @@ pub fn bytes_to_hex(s: &[u8]) -> String {
 
 #[cfg(test)]
 mod test {
-    use super::{
-        bin_bytes, hex_bytes, to_bin, DoubleSha256, MerkleHashFunc, MerklePath, MerkleTree,
-    };
+    use super::{bin_bytes, hex_bytes, to_bin, DoubleSha256, MerkleHashFunc, MerkleTree};
 
     struct MerkleTreeFixture {
         data: Vec<Vec<u8>>,

stacks-common/src/util/log.rs

@@ -15,13 +15,12 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::io::Write;
-use std::sync::Mutex;
 use std::time::{Duration, SystemTime};
 use std::{env, io, thread};
 
 use chrono::prelude::*;
 use lazy_static::lazy_static;
-use slog::{BorrowedKV, Drain, FnValue, Level, Logger, OwnedKVList, Record, KV};
+use slog::{Drain, Level, Logger, OwnedKVList, Record, KV};
 use slog_term::{CountingWriter, Decorator, RecordDecorator, Serializer};
 
 lazy_static! {
@@ -191,6 +190,10 @@ impl<D: Decorator> TermFormat<D> {
 
 #[cfg(feature = "slog_json")]
 fn make_json_logger() -> Logger {
+    use std::sync::Mutex;
+
+    use slog::FnValue;
+
     let def_keys = o!("file" => FnValue(move |info| {
                           info.file()
                       }),

stacks-common/src/util/mod.rs

@@ -28,15 +28,15 @@ pub mod secp256k1;
 pub mod uint;
 pub mod vrf;
 
-use std::collections::HashMap;
 use std::fs::File;
 use std::io::{BufReader, BufWriter, Write};
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{error, fmt, thread, time};
 
 /// Given a relative path inside the Cargo workspace, return the absolute path
-pub fn cargo_workspace<P>(relative_path: P) -> PathBuf
+#[cfg(any(test, feature = "testing"))]
+pub fn cargo_workspace<P>(relative_path: P) -> std::path::PathBuf
 where
     P: AsRef<Path>,
 {

stacks-common/src/util/pipe.rs

@@ -21,8 +21,6 @@ use std::io;
 use std::io::{Read, Write};
 use std::sync::mpsc::{sync_channel, Receiver, SyncSender, TryRecvError, TrySendError};
 
-use crate::util::log;
-
 /// Inter-thread pipe for streaming messages, built on channels.
 /// Used mainly in conjunction with networking.
 ///
@@ -316,15 +314,13 @@ impl Write for PipeWrite {
 
 #[cfg(test)]
 mod test {
-    use std::io::prelude::*;
     use std::io::{Read, Write};
     use std::{io, thread};
 
     use rand;
     use rand::RngCore;
 
     use super::*;
-    use crate::util::*;
 
     #[test]
     fn test_connection_pipe_oneshot() {

stacks-common/src/util/retry.rs

@@ -18,11 +18,7 @@
 */
 
 use std::io;
-use std::io::prelude::*;
-use std::io::{Read, Write};
-
-use crate::util::hash::to_hex;
-use crate::util::log;
+use std::io::Read;
 
 /// Wrap a Read so that we store a copy of what was read.
 /// Used for re-trying reads when we don't know what to expect from the stream.

stacks-common/src/util/secp256k1.rs

@@ -13,7 +13,7 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use rand::{thread_rng, RngCore};
+use rand::RngCore;
 use secp256k1;
 use secp256k1::ecdsa::{
     RecoverableSignature as LibSecp256k1RecoverableSignature, RecoveryId as LibSecp256k1RecoveryID,
@@ -24,11 +24,9 @@ use secp256k1::{
     PublicKey as LibSecp256k1PublicKey, Secp256k1, SecretKey as LibSecp256k1PrivateKey,
 };
 use serde::de::{Deserialize, Error as de_Error};
-use serde::ser::Error as ser_Error;
 use serde::Serialize;
 
 use super::hash::Sha256Sum;
-use crate::impl_byte_array_message_codec;
 use crate::types::{PrivateKey, PublicKey};
 use crate::util::hash::{hex_bytes, to_hex};
 
@@ -436,8 +434,8 @@ mod tests {
     use secp256k1::{PublicKey as LibSecp256k1PublicKey, Secp256k1};
 
     use super::*;
+    use crate::util::get_epoch_time_ms;
     use crate::util::hash::hex_bytes;
-    use crate::util::{get_epoch_time_ms, log};
 
     struct KeyFixture<I, R> {
         input: I,

stacks-common/src/util/vrf.rs

@@ -22,16 +22,11 @@ use std::fmt::Debug;
 use std::hash::{Hash, Hasher};
 /// This codebase is based on routines defined in the IETF draft for verifiable random functions
 /// over elliptic curves (https://tools.ietf.org/id/draft-irtf-cfrg-vrf-02.html).
-use std::ops::Deref;
-use std::ops::DerefMut;
 use std::{error, fmt};
 
 use curve25519_dalek::constants::ED25519_BASEPOINT_POINT;
 use curve25519_dalek::edwards::{CompressedEdwardsY, EdwardsPoint};
 use curve25519_dalek::scalar::Scalar as ed25519_Scalar;
-use ed25519_dalek::{
-    SecretKey as EdDalekSecretKeyBytes, SigningKey as EdPrivateKey, VerifyingKey as EdPublicKey,
-};
 use rand;
 use sha2::{Digest, Sha512};
 
@@ -535,10 +530,8 @@ impl VRF {
 
 #[cfg(test)]
 mod tests {
-    use curve25519_dalek::scalar::Scalar as ed25519_Scalar;
     use rand;
     use rand::RngCore;
-    use sha2::Sha512;
 
     use super::*;
     use crate::util::hash::hex_bytes;