diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml index 419a1b6e1b..41e1f95bc4 100644 --- a/.github/workflows/bitcoin-tests.yml +++ b/.github/workflows/bitcoin-tests.yml @@ -58,7 +58,6 @@ jobs: exclude: # The following tests are excluded from CI runs. Some of these may be # worth investigating adding back into the CI - - test-name: tests::bitcoin_regtest::bitcoind_integration_test_segwit - test-name: tests::nakamoto_integrations::consensus_hash_event_dispatcher - test-name: tests::neon_integrations::atlas_integration_test - test-name: tests::neon_integrations::atlas_stress_integration_test diff --git a/stacks-node/src/burnchains/bitcoin/core_controller.rs b/stacks-node/src/burnchains/bitcoin/core_controller.rs new file mode 100644 index 0000000000..dee30556fe --- /dev/null +++ b/stacks-node/src/burnchains/bitcoin/core_controller.rs @@ -0,0 +1,190 @@ +// Copyright (C) 2025 Stacks Open Internet Foundation +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Bitcoin Core module +//! +//! This module provides convenient APIs for managing a `bitcoind` process, +//! including utilities to quickly start and stop instances for testing or +//! development purposes. + +use std::io::{BufRead, BufReader}; +use std::process::{Child, Command, Stdio}; + +use crate::burnchains::rpc::bitcoin_rpc_client::BitcoinRpcClient; +use crate::Config; + +// Value usable as `BurnchainConfig::peer_port` to avoid bitcoind peer port binding +pub const BURNCHAIN_CONFIG_PEER_PORT_DISABLED: u16 = 0; + +/// Errors that can occur when managing a `bitcoind` process. +#[derive(Debug, thiserror::Error)] +pub enum BitcoinCoreError { + /// Returned when the `bitcoind` process fails to start. + #[error("bitcoind spawn failed: {0}")] + SpawnFailed(String), + /// Returned when an attempt to stop the `bitcoind` process fails. + #[error("bitcoind stop failed: {0}")] + StopFailed(String), + /// Returned when an attempt to forcibly kill the `bitcoind` process fails. + #[error("bitcoind kill failed: {0}")] + KillFailed(String), +} + +type BitcoinResult = Result; + +/// Represents a managed `bitcoind` process instance. +pub struct BitcoinCoreController { + /// Handle to the spawned `bitcoind` process. + bitcoind_process: Option, + /// Command-line arguments used to launch the process. + args: Vec, + /// Path to the data directory used by `bitcoind`. + data_path: String, + /// RPC client for communicating with the `bitcoind` instance. + rpc_client: BitcoinRpcClient, +} + +impl BitcoinCoreController { + /// Create a [`BitcoinCoreController`] from Stacks Configuration + pub fn from_stx_config(config: &Config) -> Self { + let client = + BitcoinRpcClient::from_stx_config(config).expect("rpc client creation failed!"); + Self::from_stx_config_and_client(config, client) + } + + /// Create a [`BitcoinCoreController`] from Stacks Configuration (mainly using [`stacks::config::BurnchainConfig`]) + /// and an rpc client [`BitcoinRpcClient`] + pub fn from_stx_config_and_client(config: &Config, client: BitcoinRpcClient) -> Self { + let mut result = BitcoinCoreController { + bitcoind_process: None, + args: vec![], + data_path: config.get_burnchain_path_str(), + rpc_client: client, + }; + + result.add_arg("-regtest"); + result.add_arg("-nodebug"); + result.add_arg("-nodebuglogfile"); + result.add_arg("-rest"); + result.add_arg("-persistmempool=1"); + result.add_arg("-dbcache=100"); + result.add_arg("-txindex=1"); + result.add_arg("-server=1"); + result.add_arg("-listenonion=0"); + result.add_arg("-rpcbind=127.0.0.1"); + result.add_arg(format!("-datadir={}", result.data_path)); + + let peer_port = config.burnchain.peer_port; + if peer_port == BURNCHAIN_CONFIG_PEER_PORT_DISABLED { + info!("Peer Port is disabled. So `-listen=0` flag will be used"); + result.add_arg("-listen=0"); + } else { + result.add_arg(format!("-port={peer_port}")); + } + + result.add_arg(format!("-rpcport={}", config.burnchain.rpc_port)); + + if let (Some(username), Some(password)) = + (&config.burnchain.username, &config.burnchain.password) + { + result.add_arg(format!("-rpcuser={username}")); + result.add_arg(format!("-rpcpassword={password}")); + } + + result + } + + /// Add argument (like "-name=value") to be used to run bitcoind process + pub fn add_arg(&mut self, arg: impl Into) -> &mut Self { + self.args.push(arg.into()); + self + } + + /// Start Bitcoind process + pub fn start_bitcoind(&mut self) -> BitcoinResult<()> { + std::fs::create_dir_all(&self.data_path).unwrap(); + + let mut command = Command::new("bitcoind"); + command.stdout(Stdio::piped()); + + command.args(self.args.clone()); + + info!("bitcoind spawn: {command:?}"); + + let mut process = match command.spawn() { + Ok(child) => child, + Err(e) => return Err(BitcoinCoreError::SpawnFailed(format!("{e:?}"))), + }; + + let mut out_reader = BufReader::new(process.stdout.take().unwrap()); + + let mut line = String::new(); + while let Ok(bytes_read) = out_reader.read_line(&mut line) { + if bytes_read == 0 { + return Err(BitcoinCoreError::SpawnFailed( + "Bitcoind closed before spawning network".into(), + )); + } + if line.contains("Done loading") { + break; + } + } + + info!("bitcoind startup finished"); + + self.bitcoind_process = Some(process); + + Ok(()) + } + + /// Gracefully stop bitcoind process + pub fn stop_bitcoind(&mut self) -> BitcoinResult<()> { + if let Some(mut bitcoind_process) = self.bitcoind_process.take() { + let res = self + .rpc_client + .stop() + .map_err(|e| BitcoinCoreError::StopFailed(format!("{e:?}")))?; + info!("bitcoind stop started with message: '{res}'"); + bitcoind_process + .wait() + .map_err(|e| BitcoinCoreError::StopFailed(format!("{e:?}")))?; + info!("bitcoind stop finished"); + } + Ok(()) + } + + /// Kill bitcoind process + pub fn kill_bitcoind(&mut self) -> BitcoinResult<()> { + if let Some(mut bitcoind_process) = self.bitcoind_process.take() { + info!("bitcoind kill started"); + bitcoind_process + .kill() + .map_err(|e| BitcoinCoreError::KillFailed(format!("{e:?}")))?; + info!("bitcoind kill finished"); + } + Ok(()) + } + + /// Check if bitcoind process is running + pub fn is_running(&self) -> bool { + self.bitcoind_process.is_some() + } +} + +impl Drop for BitcoinCoreController { + fn drop(&mut self) { + self.kill_bitcoind().unwrap(); + } +} diff --git a/stacks-node/src/burnchains/bitcoin/mod.rs b/stacks-node/src/burnchains/bitcoin/mod.rs new file mode 100644 index 0000000000..26119f5588 --- /dev/null +++ b/stacks-node/src/burnchains/bitcoin/mod.rs @@ -0,0 +1,21 @@ +// Copyright (C) 2025 Stacks Open Internet Foundation +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Bitcoin Module +//! +//! Entry point for all bitcoin related modules + +#[cfg(test)] +pub mod core_controller; diff --git a/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/stacks-node/src/burnchains/bitcoin_regtest_controller.rs index 4945cb2031..3b6644ab0b 100644 --- a/stacks-node/src/burnchains/bitcoin_regtest_controller.rs +++ b/stacks-node/src/burnchains/bitcoin_regtest_controller.rs @@ -2793,17 +2793,6 @@ impl BitcoinRPCRequest { Ok(()) } - pub fn stop_bitcoind(config: &Config) -> RPCResult { - let payload = BitcoinRPCRequest { - method: "stop".to_string(), - params: vec![], - id: "stacks".to_string(), - jsonrpc: "2.0".to_string(), - }; - - BitcoinRPCRequest::send(config, payload) - } - pub fn send(config: &Config, payload: BitcoinRPCRequest) -> RPCResult { let request = BitcoinRPCRequest::build_rpc_request(config, &payload); let timeout = Duration::from_secs(u64::from(config.burnchain.timeout)); @@ -2834,7 +2823,7 @@ mod tests { use stacks_common::util::secp256k1::Secp256k1PrivateKey; use super::*; - use crate::tests::bitcoin_regtest::BitcoinCoreController; + use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::Keychain; mod utils { @@ -2845,7 +2834,7 @@ mod tests { use stacks::util::vrf::{VRFPrivateKey, VRFPublicKey}; use super::*; - use crate::tests::bitcoin_regtest::BURNCHAIN_CONFIG_PEER_PORT_DISABLED; + use crate::burnchains::bitcoin::core_controller::BURNCHAIN_CONFIG_PEER_PORT_DISABLED; use crate::util::get_epoch_time_nanos; pub fn create_config() -> Config { @@ -3255,7 +3244,7 @@ mod tests { let config = utils::create_config(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3280,7 +3269,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.wallet_name = String::from("mywallet"); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3308,7 +3297,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3349,7 +3338,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3373,7 +3362,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3421,7 +3410,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3452,7 +3441,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3480,7 +3469,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3522,7 +3511,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3581,7 +3570,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3630,7 +3619,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3681,7 +3670,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3764,7 +3753,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3837,7 +3826,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3882,7 +3871,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3932,7 +3921,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -3982,7 +3971,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -4018,7 +4007,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -4058,7 +4047,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -4103,7 +4092,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -4150,7 +4139,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -4183,7 +4172,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -4224,7 +4213,7 @@ mod tests { let mut config = utils::create_config(); config.burnchain.local_mining_public_key = Some(miner_pubkey.to_hex()); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); diff --git a/stacks-node/src/burnchains/mod.rs b/stacks-node/src/burnchains/mod.rs index 8bca0d1b85..aedad169a8 100644 --- a/stacks-node/src/burnchains/mod.rs +++ b/stacks-node/src/burnchains/mod.rs @@ -1,3 +1,4 @@ +pub mod bitcoin; pub mod bitcoin_regtest_controller; pub mod mocknet_controller; pub mod rpc; diff --git a/stacks-node/src/burnchains/rpc/bitcoin_rpc_client/mod.rs b/stacks-node/src/burnchains/rpc/bitcoin_rpc_client/mod.rs index e4c9e644b1..c514a984a8 100644 --- a/stacks-node/src/burnchains/rpc/bitcoin_rpc_client/mod.rs +++ b/stacks-node/src/burnchains/rpc/bitcoin_rpc_client/mod.rs @@ -334,7 +334,7 @@ impl<'de> Deserialize<'de> for BurnchainHeaderHashWrapperResponse { } /// Client for interacting with a Bitcoin RPC service. -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct BitcoinRpcClient { /// The client ID to identify the source of the requests. client_id: String, diff --git a/stacks-node/src/burnchains/rpc/rpc_transport/mod.rs b/stacks-node/src/burnchains/rpc/rpc_transport/mod.rs index e8462b189f..a62227c020 100644 --- a/stacks-node/src/burnchains/rpc/rpc_transport/mod.rs +++ b/stacks-node/src/burnchains/rpc/rpc_transport/mod.rs @@ -127,7 +127,7 @@ pub enum RpcAuth { /// /// This struct encapsulates the target URL, optional authentication, /// and an internal HTTP client. -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct RpcTransport { /// Host and port of the target JSON-RPC server. peer: PeerHost, diff --git a/stacks-node/src/tests/bitcoin/core_controller_integrations.rs b/stacks-node/src/tests/bitcoin/core_controller_integrations.rs new file mode 100644 index 0000000000..fde788a2ea --- /dev/null +++ b/stacks-node/src/tests/bitcoin/core_controller_integrations.rs @@ -0,0 +1,132 @@ +// Copyright (C) 2025 Stacks Open Internet Foundation +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Integration tests for [`BitcoinCoreController`] + +use std::env; +use std::path::Path; + +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; +use crate::{BitcoinRegtestController, BurnchainController}; + +mod utils { + use std::net::TcpListener; + + use stacks::config::Config; + use stacks::util::get_epoch_time_nanos; + + use crate::burnchains::bitcoin::core_controller::BURNCHAIN_CONFIG_PEER_PORT_DISABLED; + + pub fn create_config() -> Config { + let mut config = Config::default(); + config.burnchain.magic_bytes = "T3".as_bytes().into(); + config.burnchain.username = Some(String::from("user")); + config.burnchain.password = Some(String::from("12345")); + // overriding default "0.0.0.0" because doesn't play nicely on Windows. + config.burnchain.peer_host = String::from("127.0.0.1"); + // avoiding peer port biding to reduce the number of ports to bind to. + config.burnchain.peer_port = BURNCHAIN_CONFIG_PEER_PORT_DISABLED; + + //Ask the OS for a free port. Not guaranteed to stay free, + //after TcpListner is dropped, but good enough for testing + //and starting bitcoind right after config is created + let tmp_listener = + TcpListener::bind("127.0.0.1:0").expect("Failed to bind to get a free port"); + let port = tmp_listener.local_addr().unwrap().port(); + + config.burnchain.rpc_port = port; + + let now = get_epoch_time_nanos(); + let dir = format!("/tmp/regtest-ctrl-{port}-{now}"); + config.node.working_dir = dir; + + config + } +} + +#[test] +#[ignore] +fn test_bitcoind_start_and_stop() { + if env::var("BITCOIND_TEST") != Ok("1".into()) { + return; + } + + let config = utils::create_config(); + let data_path_str = config.get_burnchain_path_str(); + let data_path = Path::new(data_path_str.as_str()); + + let mut bitcoind = BitcoinCoreController::from_stx_config(&config); + + bitcoind.start_bitcoind().expect("should start!"); + assert!(bitcoind.is_running(), "should be running after start!"); + assert!(data_path.exists(), "data path should exists after start!"); + + bitcoind.stop_bitcoind().expect("should stop!"); + assert!(!bitcoind.is_running(), "should not be running after stop!"); + assert!(data_path.exists(), "data path should exists after stop!"); +} + +#[test] +#[ignore] +fn test_bitcoind_start_and_kill() { + if env::var("BITCOIND_TEST") != Ok("1".into()) { + return; + } + + let config = utils::create_config(); + let data_path_str = config.get_burnchain_path_str(); + let data_path = Path::new(data_path_str.as_str()); + + let mut bitcoind = BitcoinCoreController::from_stx_config(&config); + + bitcoind.start_bitcoind().expect("should start!"); + assert!(bitcoind.is_running(), "should be running after start!"); + assert!(data_path.exists(), "data path should exists after start!"); + + bitcoind.kill_bitcoind().expect("should kill!"); + assert!(!bitcoind.is_running(), "should not be running after kill!"); + assert!(data_path.exists(), "data path should exists after kill!"); +} + +#[test] +#[ignore] +fn test_bitcoind_restart_with_bootstrapped_chain_data() { + if env::var("BITCOIND_TEST") != Ok("1".into()) { + return; + } + + let config = utils::create_config(); + + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); + btcd_controller + .start_bitcoind() + .expect("Failed starting bitcoind"); + + let btc_controller = BitcoinRegtestController::new(config, None); + btc_controller.bootstrap_chain(201); + info!("Chain bootstrapped..."); + + btcd_controller + .stop_bitcoind() + .expect("Failed to stop bitcoind"); + + btcd_controller + .start_bitcoind() + .expect("Failed to restart bitcoind"); + + btcd_controller + .stop_bitcoind() + .expect("Failed to re-stop bitcoind"); +} diff --git a/stacks-node/src/tests/bitcoin/mod.rs b/stacks-node/src/tests/bitcoin/mod.rs new file mode 100644 index 0000000000..9e7b9792fe --- /dev/null +++ b/stacks-node/src/tests/bitcoin/mod.rs @@ -0,0 +1,20 @@ +// Copyright (C) 2025 Stacks Open Internet Foundation +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Bitcoin Integration Test Module +//! +//! Entry point for all bitcoin related test modules + +mod core_controller_integrations; diff --git a/stacks-node/src/tests/bitcoin_regtest.rs b/stacks-node/src/tests/bitcoin_regtest.rs deleted file mode 100644 index 6b535c6bad..0000000000 --- a/stacks-node/src/tests/bitcoin_regtest.rs +++ /dev/null @@ -1,651 +0,0 @@ -use std::env; -use std::io::{BufRead, BufReader}; -use std::process::{Child, Command, Stdio}; - -use clarity::vm::costs::ExecutionCost; -use stacks::chainstate::burn::operations::BlockstackOperationType::{ - LeaderBlockCommit, LeaderKeyRegister, -}; -use stacks::chainstate::stacks::StacksPrivateKey; -use stacks::config::InitialBalance; -use stacks::core::StacksEpochId; -use stacks_common::util::hash::hex_bytes; - -use super::PUBLISH_CONTRACT; -use crate::burnchains::bitcoin_regtest_controller::BitcoinRPCRequest; -use crate::helium::RunLoop; -use crate::tests::to_addr; -use crate::Config; - -// Value usable as `BurnchainConfig::peer_port` to avoid bitcoind peer port binding -pub const BURNCHAIN_CONFIG_PEER_PORT_DISABLED: u16 = 0; - -#[derive(Debug, thiserror::Error)] -pub enum BitcoinCoreError { - #[error("bitcoind spawn failed: {0}")] - SpawnFailed(String), - #[error("bitcoind stop failed: {0}")] - StopFailed(String), -} - -type BitcoinResult = Result; - -pub struct BitcoinCoreController { - bitcoind_process: Option, - config: Config, - args: Vec, -} - -impl BitcoinCoreController { - /// TODO: to be removed in favor of [`Self::from_stx_config`] - pub fn new(config: Config) -> BitcoinCoreController { - BitcoinCoreController { - bitcoind_process: None, - config, - args: vec![], - } - } - - /// Create a [`BitcoinCoreController`] from Stacks Configuration, mainly using [`stacks::config::BurnchainConfig`] - pub fn from_stx_config(config: Config) -> Self { - let mut result = BitcoinCoreController { - bitcoind_process: None, - config: config.clone(), //TODO: clone can be removed once - args: vec![], - }; - - result.add_arg("-regtest"); - result.add_arg("-nodebug"); - result.add_arg("-nodebuglogfile"); - result.add_arg("-rest"); - result.add_arg("-persistmempool=1"); - result.add_arg("-dbcache=100"); - result.add_arg("-txindex=1"); - result.add_arg("-server=1"); - result.add_arg("-listenonion=0"); - result.add_arg("-rpcbind=127.0.0.1"); - result.add_arg(format!("-datadir={}", config.get_burnchain_path_str())); - - let peer_port = config.burnchain.peer_port; - if peer_port == BURNCHAIN_CONFIG_PEER_PORT_DISABLED { - info!("Peer Port is disabled. So `-listen=0` flag will be used"); - result.add_arg("-listen=0"); - } else { - result.add_arg(format!("-port={}", peer_port)); - } - - result.add_arg(format!("-rpcport={}", config.burnchain.rpc_port)); - - if let (Some(username), Some(password)) = - (&config.burnchain.username, &config.burnchain.password) - { - result.add_arg(format!("-rpcuser={username}")); - result.add_arg(format!("-rpcpassword={password}")); - } - - result - } - - /// Add argument (like "-name=value") to be used to run bitcoind process - pub fn add_arg(&mut self, arg: impl Into) -> &mut Self { - self.args.push(arg.into()); - self - } - - /// Start Bitcoind process - pub fn start_bitcoind_v2(&mut self) -> BitcoinResult<()> { - std::fs::create_dir_all(self.config.get_burnchain_path_str()).unwrap(); - - let mut command = Command::new("bitcoind"); - command.stdout(Stdio::piped()); - - command.args(self.args.clone()); - - eprintln!("bitcoind spawn: {command:?}"); - - let mut process = match command.spawn() { - Ok(child) => child, - Err(e) => return Err(BitcoinCoreError::SpawnFailed(format!("{e:?}"))), - }; - - let mut out_reader = BufReader::new(process.stdout.take().unwrap()); - - let mut line = String::new(); - while let Ok(bytes_read) = out_reader.read_line(&mut line) { - if bytes_read == 0 { - return Err(BitcoinCoreError::SpawnFailed( - "Bitcoind closed before spawning network".into(), - )); - } - if line.contains("Done loading") { - break; - } - } - - eprintln!("bitcoind startup finished"); - - self.bitcoind_process = Some(process); - - Ok(()) - } - - fn add_rpc_cli_args(&self, command: &mut Command) { - command.arg(format!("-rpcport={}", self.config.burnchain.rpc_port)); - - if let (Some(username), Some(password)) = ( - &self.config.burnchain.username, - &self.config.burnchain.password, - ) { - command - .arg(format!("-rpcuser={username}")) - .arg(format!("-rpcpassword={password}")); - } - } - - /// TODO: to be removed in favor of [`Self::start_bitcoind_v2`] - pub fn start_bitcoind(&mut self) -> BitcoinResult<()> { - std::fs::create_dir_all(self.config.get_burnchain_path_str()).unwrap(); - - let mut command = Command::new("bitcoind"); - command - .stdout(Stdio::piped()) - .arg("-regtest") - .arg("-nodebug") - .arg("-nodebuglogfile") - .arg("-rest") - .arg("-persistmempool=1") - .arg("-dbcache=100") - .arg("-txindex=1") - .arg("-server=1") - .arg("-listenonion=0") - .arg("-rpcbind=127.0.0.1") - .arg(format!("-datadir={}", self.config.get_burnchain_path_str())); - - let peer_port = self.config.burnchain.peer_port; - if peer_port == BURNCHAIN_CONFIG_PEER_PORT_DISABLED { - info!("Peer Port is disabled. So `-listen=0` flag will be used"); - command.arg("-listen=0"); - } else { - command.arg(format!("-port={}", peer_port)); - } - - self.add_rpc_cli_args(&mut command); - - eprintln!("bitcoind spawn: {command:?}"); - - let mut process = match command.spawn() { - Ok(child) => child, - Err(e) => return Err(BitcoinCoreError::SpawnFailed(format!("{e:?}"))), - }; - - let mut out_reader = BufReader::new(process.stdout.take().unwrap()); - - let mut line = String::new(); - while let Ok(bytes_read) = out_reader.read_line(&mut line) { - if bytes_read == 0 { - return Err(BitcoinCoreError::SpawnFailed( - "Bitcoind closed before spawning network".into(), - )); - } - if line.contains("Done loading") { - break; - } - } - - eprintln!("bitcoind startup finished"); - - self.bitcoind_process = Some(process); - - Ok(()) - } - - pub fn stop_bitcoind(&mut self) -> Result<(), BitcoinCoreError> { - if let Some(mut bitcoind_process) = self.bitcoind_process.take() { - let res = BitcoinRPCRequest::stop_bitcoind(&self.config) - .map_err(|e| BitcoinCoreError::StopFailed(format!("{e:?}")))?; - - if let Some(err) = res.get("error") { - if !err.is_null() { - return Err(BitcoinCoreError::StopFailed(format!("{err}"))); - } - } else if let Some(_result) = res.get("result") { - // Expected, continue - } else { - return Err(BitcoinCoreError::StopFailed(format!( - "Invalid response: {res:?}" - ))); - } - - bitcoind_process.wait().unwrap(); - } - Ok(()) - } - - pub fn kill_bitcoind(&mut self) { - if let Some(mut bitcoind_process) = self.bitcoind_process.take() { - bitcoind_process.kill().unwrap(); - } - } -} - -impl Drop for BitcoinCoreController { - fn drop(&mut self) { - self.kill_bitcoind(); - } -} - -const BITCOIND_INT_TEST_COMMITS: u64 = 11000; - -#[test] -#[ignore] -fn bitcoind_integration_test() { - if env::var("BITCOIND_TEST") != Ok("1".into()) { - return; - } - bitcoind_integration(false); -} - -#[test] -#[ignore] -fn bitcoind_integration_test_segwit() { - if env::var("BITCOIND_TEST") != Ok("1".into()) { - return; - } - bitcoind_integration(true); -} - -fn bitcoind_integration(segwit_flag: bool) { - let mut conf = super::new_test_conf(); - conf.burnchain.commit_anchor_block_within = 2000; - conf.burnchain.burn_fee_cap = BITCOIND_INT_TEST_COMMITS; - conf.burnchain.mode = "helium".to_string(); - conf.burnchain.peer_host = "127.0.0.1".to_string(); - conf.burnchain.rpc_port = 18443; - conf.burnchain.username = Some("helium-node".to_string()); - conf.burnchain.password = Some("secret".to_string()); - conf.burnchain.local_mining_public_key = Some("04ee0b1602eb18fef7986887a7e8769a30c9df981d33c8380d255edef003abdcd243a0eb74afdf6740e6c423e62aec631519a24cf5b1d62bf8a3e06ddc695dcb77".to_string()); - - conf.miner.first_attempt_time_ms = i64::MAX as u64; - conf.miner.subsequent_attempt_time_ms = i64::MAX as u64; - conf.miner.segwit = segwit_flag; - - conf.initial_balances.push(InitialBalance { - address: to_addr( - &StacksPrivateKey::from_hex( - "043ff5004e3d695060fa48ac94c96049b8c14ef441c50a184a6a3875d2a000f3", - ) - .unwrap(), - ) - .into(), - amount: 1000, - }); - conf.initial_balances.push(InitialBalance { - address: to_addr( - &StacksPrivateKey::from_hex( - "b1cf9cee5083f421c84d7cb53be5edf2801c3c78d63d53917aee0bdc8bd160ee01", - ) - .unwrap(), - ) - .into(), - amount: 1000, - }); - - // Setup up a bitcoind controller - let mut controller = BitcoinCoreController::new(conf.clone()); - // Start bitcoind - let _res = controller.start_bitcoind(); - - let num_rounds = 6; - let mut run_loop = RunLoop::new(conf.clone()); - - run_loop - .callbacks - .on_burn_chain_initialized(|burnchain_controller| { - burnchain_controller.bootstrap_chain(2001); - }); - - // In this serie of tests, the callback is fired post-burnchain-sync, pre-stacks-sync - run_loop - .callbacks - .on_new_burn_chain_state(|round, burnchain_tip, chain_tip| { - let block = &burnchain_tip.block_snapshot; - let expected_total_burn = BITCOIND_INT_TEST_COMMITS * (round + 1); - assert_eq!(block.total_burn, expected_total_burn); - assert!(block.sortition); - assert_eq!(block.num_sortitions, round + 1); - assert_eq!(block.block_height, round + 2003); - let leader_key = "f888e0cab5c16de8edf72b544a189ece5c0b95cd9178606c970789ac71d17bb4"; - - match round { - 0 => { - let state_transition = &burnchain_tip.state_transition; - assert!(state_transition.accepted_ops.len() == 1); - assert!(state_transition.consumed_leader_keys.len() == 1); - - for op in &state_transition.accepted_ops { - match op { - LeaderKeyRegister(_op) => { - unreachable!(); - } - LeaderBlockCommit(op) => { - assert_eq!( - burnchain_tip.state_transition.consumed_leader_keys[0] - .public_key - .to_hex(), - leader_key - ); - assert!(op.parent_block_ptr == 0); - assert!(op.parent_vtxindex == 0); - assert_eq!(op.burn_fee, BITCOIND_INT_TEST_COMMITS); - } - _ => panic!("Unexpected operation"), - } - } - } - 1 => { - let state_transition = &burnchain_tip.state_transition; - assert!(state_transition.accepted_ops.len() == 1); - assert!(state_transition.consumed_leader_keys.len() == 1); - - for op in &state_transition.accepted_ops { - match op { - LeaderKeyRegister(_op) => { - unreachable!(); - } - LeaderBlockCommit(op) => { - assert_eq!( - burnchain_tip.state_transition.consumed_leader_keys[0] - .public_key - .to_hex(), - leader_key - ); - assert_eq!(op.parent_block_ptr, 2003); - assert_eq!(op.burn_fee, BITCOIND_INT_TEST_COMMITS); - } - _ => panic!("Unexpected operation"), - } - } - - assert!( - burnchain_tip.block_snapshot.parent_burn_header_hash - == chain_tip.metadata.burn_header_hash - ); - } - 2 => { - let state_transition = &burnchain_tip.state_transition; - assert!(state_transition.accepted_ops.len() == 1); - assert!(state_transition.consumed_leader_keys.len() == 1); - - for op in &state_transition.accepted_ops { - match op { - LeaderKeyRegister(_op) => { - unreachable!(); - } - LeaderBlockCommit(op) => { - assert_eq!( - burnchain_tip.state_transition.consumed_leader_keys[0] - .public_key - .to_hex(), - leader_key - ); - assert_eq!(op.parent_block_ptr, 2004); - assert_eq!(op.burn_fee, BITCOIND_INT_TEST_COMMITS); - } - _ => panic!("Unexpected operation"), - } - } - - assert!( - burnchain_tip.block_snapshot.parent_burn_header_hash - == chain_tip.metadata.burn_header_hash - ); - } - 3 => { - let state_transition = &burnchain_tip.state_transition; - assert!(state_transition.accepted_ops.len() == 1); - assert!(state_transition.consumed_leader_keys.len() == 1); - - for op in &state_transition.accepted_ops { - match op { - LeaderKeyRegister(_op) => { - unreachable!(); - } - LeaderBlockCommit(op) => { - assert_eq!( - burnchain_tip.state_transition.consumed_leader_keys[0] - .public_key - .to_hex(), - leader_key - ); - assert_eq!(op.parent_block_ptr, 2005); - assert_eq!(op.burn_fee, BITCOIND_INT_TEST_COMMITS); - } - _ => panic!("Unexpected operation"), - } - } - - assert!( - burnchain_tip.block_snapshot.parent_burn_header_hash - == chain_tip.metadata.burn_header_hash - ); - } - 4 => { - let state_transition = &burnchain_tip.state_transition; - assert!(state_transition.accepted_ops.len() == 1); - assert!(state_transition.consumed_leader_keys.len() == 1); - - for op in &state_transition.accepted_ops { - match op { - LeaderKeyRegister(_op) => { - unreachable!(); - } - LeaderBlockCommit(op) => { - assert_eq!( - burnchain_tip.state_transition.consumed_leader_keys[0] - .public_key - .to_hex(), - leader_key - ); - assert_eq!(op.parent_block_ptr, 2006); - assert_eq!(op.burn_fee, BITCOIND_INT_TEST_COMMITS); - } - _ => panic!("Unexpected operation"), - } - } - - assert!( - burnchain_tip.block_snapshot.parent_burn_header_hash - == chain_tip.metadata.burn_header_hash - ); - } - 5 => { - let state_transition = &burnchain_tip.state_transition; - assert!(state_transition.accepted_ops.len() == 1); - assert!(state_transition.consumed_leader_keys.len() == 1); - - for op in &state_transition.accepted_ops { - match op { - LeaderKeyRegister(_op) => { - unreachable!(); - } - LeaderBlockCommit(op) => { - assert_eq!( - burnchain_tip.state_transition.consumed_leader_keys[0] - .public_key - .to_hex(), - leader_key - ); - assert_eq!(op.parent_block_ptr, 2007); - assert_eq!(op.burn_fee, BITCOIND_INT_TEST_COMMITS); - } - _ => panic!("Unexpected operation"), - } - } - - assert!( - burnchain_tip.block_snapshot.parent_burn_header_hash - == chain_tip.metadata.burn_header_hash - ); - } - _ => {} - } - }); - - // Use tenure's hook for submitting transactions - run_loop.callbacks.on_new_tenure(|round, _burnchain_tip, chain_tip, tenure| { - let mut chainstate_copy = tenure.open_chainstate(); - let sortdb = tenure.open_fake_sortdb(); - - match round { - 1 => { - // On round 1, publish the KV contract - // $ cat /tmp/out.clar - // (define-map store { key: (string-ascii 32) } { value: (string-ascii 32) }) - // (define-public (get-value (key (string-ascii 32))) - // (begin - // (print (concat "Getting key " key)) - // (match (map-get? store { key: key }) - // entry (ok (get value entry)) - // (err 0)))) - // (define-public (set-value (key (string-ascii 32)) (value (string-ascii 32))) - // (begin - // (print (concat "Setting key " key)) - // (map-set store { key: key } { value: value }) - // (ok 'true))) - // ./blockstack-cli --testnet publish 043ff5004e3d695060fa48ac94c96049b8c14ef441c50a184a6a3875d2a000f3 0 0 store /tmp/out.clar - let header_hash = chain_tip.block.block_hash(); - let consensus_hash = chain_tip.metadata.consensus_hash; - tenure.mem_pool.submit_raw(&mut chainstate_copy, &sortdb, &consensus_hash, &header_hash, PUBLISH_CONTRACT.to_owned(), &ExecutionCost::max_value(), - &StacksEpochId::Epoch20,).unwrap(); - }, - 2 => { - // On round 2, publish a "get:foo" transaction - // ./blockstack-cli --testnet contract-call 043ff5004e3d695060fa48ac94c96049b8c14ef441c50a184a6a3875d2a000f3 10 1 STGT7GSMZG7EA0TS6MVSKT5JC1DCDFGZWJJZXN8A store get-value -e \"foo\" - let header_hash = chain_tip.block.block_hash(); - let consensus_hash = chain_tip.metadata.consensus_hash; - let get_foo = "8080000000040021a3c334fc0ee50359353799e8b2605ac6be1fe40000000000000001000000000000000a0100b7ff8b6c20c427b4f4f09c1ad7e50027e2b076b2ddc0ab55e64ef5ea3771dd4763a79bc5a2b1a79b72ce03dd146ccf24b84942d675a815819a8b85aa8065dfaa030200000000021a21a3c334fc0ee50359353799e8b2605ac6be1fe40573746f7265096765742d76616c7565000000010d00000003666f6f"; - tenure.mem_pool.submit_raw(&mut chainstate_copy, &sortdb, &consensus_hash, &header_hash,hex_bytes(get_foo).unwrap().to_vec(), &ExecutionCost::max_value(), - &StacksEpochId::Epoch20,).unwrap(); - }, - 3 => { - // On round 3, publish a "set:foo=bar" transaction - // ./blockstack-cli --testnet contract-call 043ff5004e3d695060fa48ac94c96049b8c14ef441c50a184a6a3875d2a000f3 10 2 STGT7GSMZG7EA0TS6MVSKT5JC1DCDFGZWJJZXN8A store set-value -e \"foo\" -e \"bar\" - let header_hash = chain_tip.block.block_hash(); - let consensus_hash = chain_tip.metadata.consensus_hash; - let set_foo_bar = "8080000000040021a3c334fc0ee50359353799e8b2605ac6be1fe40000000000000002000000000000000a010142a01caf6a32b367664869182f0ebc174122a5a980937ba259d44cc3ebd280e769a53dd3913c8006ead680a6e1c98099fcd509ce94b0a4e90d9f4603b101922d030200000000021a21a3c334fc0ee50359353799e8b2605ac6be1fe40573746f7265097365742d76616c7565000000020d00000003666f6f0d00000003626172"; - tenure.mem_pool.submit_raw(&mut chainstate_copy, &sortdb, &consensus_hash, &header_hash,hex_bytes(set_foo_bar).unwrap().to_vec(), &ExecutionCost::max_value(), - &StacksEpochId::Epoch20,).unwrap(); - }, - 4 => { - // On round 4, publish a "get:foo" transaction - // ./blockstack-cli --testnet contract-call 043ff5004e3d695060fa48ac94c96049b8c14ef441c50a184a6a3875d2a000f3 10 3 STGT7GSMZG7EA0TS6MVSKT5JC1DCDFGZWJJZXN8A store get-value -e \"foo\" - let header_hash = chain_tip.block.block_hash(); - let consensus_hash = chain_tip.metadata.consensus_hash; - let get_foo = "8080000000040021a3c334fc0ee50359353799e8b2605ac6be1fe40000000000000003000000000000000a010046c2c1c345231443fef9a1f64fccfef3e1deacc342b2ab5f97612bb3742aa799038b20aea456789aca6b883e52f84a31adfee0bc2079b740464877af8f2f87d2030200000000021a21a3c334fc0ee50359353799e8b2605ac6be1fe40573746f7265096765742d76616c7565000000010d00000003666f6f"; - tenure.mem_pool.submit_raw(&mut chainstate_copy, &sortdb, &consensus_hash, &header_hash,hex_bytes(get_foo).unwrap().to_vec(), &ExecutionCost::max_value(), - &StacksEpochId::Epoch20,).unwrap(); - }, - 5 => { - // On round 5, publish a stacks transaction - // ./blockstack-cli --testnet token-transfer b1cf9cee5083f421c84d7cb53be5edf2801c3c78d63d53917aee0bdc8bd160ee01 10 0 ST195Q2HPXY576N4CT2A0R94D7DRYSX54A5X3YZTH 1000 - let header_hash = chain_tip.block.block_hash(); - let consensus_hash = chain_tip.metadata.consensus_hash; - let transfer_1000_stx = "80800000000400b71a091b4b8b7661a661c620966ab6573bc2dcd30000000000000000000000000000000a0000393810832bacd44cfc4024980876135de6b95429bdb610d5ce96a92c9ee9bfd81ec77ea0f1748c8515fc9a1589e51d8b92bf028e3e84ade1249682c05271d5b803020000000000051a525b8a36ef8a73548cd0940c248d3b71ecf4a45100000000000003e800000000000000000000000000000000000000000000000000000000000000000000"; - tenure.mem_pool.submit_raw(&mut chainstate_copy, &sortdb, &consensus_hash, &header_hash,hex_bytes(transfer_1000_stx).unwrap().to_vec(), &ExecutionCost::max_value(), - &StacksEpochId::Epoch20,).unwrap(); - }, - _ => {} - }; - }); - - // Use block's hook for asserting expectations - // In this serie of tests, the callback is fired post-burnchain-sync, post-stacks-sync - run_loop.callbacks.on_new_stacks_chain_state( - |round, burnchain_tip, chain_tip, _chain_state, _burn_dbconn| { - match round { - 0 => { - // Inspecting the chain at round 0. - // - Chain length should be 1. - assert!(chain_tip.metadata.stacks_block_height == 1); - - // Block #1 should only have 0 txs - assert!(chain_tip.block.txs.len() == 1); - - assert!( - chain_tip.block.header.block_hash() - == burnchain_tip.block_snapshot.winning_stacks_block_hash - ); - } - 1 => { - // Inspecting the chain at round 1. - // - Chain length should be 2. - assert!(chain_tip.metadata.stacks_block_height == 2); - - // Block #2 should only have 2 txs - assert!(chain_tip.block.txs.len() == 2); - - assert!( - chain_tip.block.header.block_hash() - == burnchain_tip.block_snapshot.winning_stacks_block_hash - ); - } - 2 => { - // Inspecting the chain at round 2. - // - Chain length should be 3. - assert!(chain_tip.metadata.stacks_block_height == 3); - - // Block #3 should only have 2 txs - assert!(chain_tip.block.txs.len() == 2); - - assert!( - chain_tip.block.header.block_hash() - == burnchain_tip.block_snapshot.winning_stacks_block_hash - ); - } - 3 => { - // Inspecting the chain at round 3. - // - Chain length should be 4. - assert!(chain_tip.metadata.stacks_block_height == 4); - - // Block #4 should only have 2 txs - assert!(chain_tip.block.txs.len() == 2); - - assert!( - chain_tip.block.header.block_hash() - == burnchain_tip.block_snapshot.winning_stacks_block_hash - ); - } - 4 => { - // Inspecting the chain at round 4. - // - Chain length should be 5. - assert!(chain_tip.metadata.stacks_block_height == 5); - - // Block #5 should only have 2 txs - assert!(chain_tip.block.txs.len() == 2); - - assert!( - chain_tip.block.header.block_hash() - == burnchain_tip.block_snapshot.winning_stacks_block_hash - ); - } - 5 => { - // Inspecting the chain at round 5. - // - Chain length should be 6. - assert!(chain_tip.metadata.stacks_block_height == 6); - - // Block #6 should only have 2 txs - assert!(chain_tip.block.txs.len() == 2); - - assert!( - chain_tip.block.header.block_hash() - == burnchain_tip.block_snapshot.winning_stacks_block_hash - ); - } - _ => {} - } - }, - ); - run_loop.start(num_rounds).unwrap(); - - controller.kill_bitcoind(); -} diff --git a/stacks-node/src/tests/bitcoin_rpc_integrations.rs b/stacks-node/src/tests/bitcoin_rpc_integrations.rs index 2f6801b53d..433e5f5b0a 100644 --- a/stacks-node/src/tests/bitcoin_rpc_integrations.rs +++ b/stacks-node/src/tests/bitcoin_rpc_integrations.rs @@ -22,12 +22,12 @@ use stacks::burnchains::bitcoin::BitcoinNetworkType; use stacks::core::BITCOIN_REGTEST_FIRST_BLOCK_HASH; use stacks::types::chainstate::BurnchainHeaderHash; +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::burnchains::rpc::bitcoin_rpc_client::test_utils::AddressType; use crate::burnchains::rpc::bitcoin_rpc_client::{ BitcoinRpcClient, BitcoinRpcClientError, ImportDescriptorsRequest, Timestamp, }; use crate::burnchains::rpc::rpc_transport::RpcError; -use crate::tests::bitcoin_regtest::BitcoinCoreController; mod utils { use std::net::TcpListener; @@ -64,12 +64,12 @@ mod utils { config } - pub fn create_client_no_auth_from_stx_config(config: Config) -> BitcoinRpcClient { + pub fn create_client_no_auth_from_stx_config(config: &Config) -> BitcoinRpcClient { BitcoinRpcClient::new( - config.burnchain.peer_host, + config.burnchain.peer_host.clone(), config.burnchain.rpc_port, RpcAuth::None, - config.burnchain.wallet_name, + config.burnchain.wallet_name.clone(), config.burnchain.timeout, "stacks".to_string(), ) @@ -86,12 +86,12 @@ fn test_rpc_call_fails_when_bitcond_with_auth_but_rpc_no_auth() { let config_with_auth = utils::create_stx_config(); - let mut btcd_controller = BitcoinCoreController::new(config_with_auth.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config_with_auth); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); - let client = utils::create_client_no_auth_from_stx_config(config_with_auth); + let client = utils::create_client_no_auth_from_stx_config(&config_with_auth); let err = client.get_blockchain_info().expect_err("Should fail!"); @@ -112,13 +112,14 @@ fn test_rpc_call_fails_when_bitcond_no_auth_and_rpc_no_auth() { config_no_auth.burnchain.username = None; config_no_auth.burnchain.password = None; - let mut btcd_controller = BitcoinCoreController::new(config_no_auth.clone()); + let client = utils::create_client_no_auth_from_stx_config(&config_no_auth); + + let mut btcd_controller = + BitcoinCoreController::from_stx_config_and_client(&config_no_auth, client.clone()); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); - let client = utils::create_client_no_auth_from_stx_config(config_no_auth); - let err = client.get_blockchain_info().expect_err("Should fail!"); assert!( @@ -152,7 +153,7 @@ fn test_get_blockchain_info_ok() { let config = utils::create_stx_config(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -178,7 +179,7 @@ fn test_wallet_listing_and_creation_ok() { let config = utils::create_stx_config(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -215,7 +216,7 @@ fn test_wallet_creation_fails_if_already_exists() { let config = utils::create_stx_config(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -251,7 +252,7 @@ fn test_get_new_address_for_each_address_type() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -306,7 +307,7 @@ fn test_generate_to_address_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -333,7 +334,7 @@ fn test_list_unspent_empty_with_empty_wallet() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -357,7 +358,7 @@ fn test_list_unspent_with_defaults() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -389,7 +390,7 @@ fn test_list_unspent_one_address_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -442,7 +443,7 @@ fn test_list_unspent_two_addresses_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -505,7 +506,7 @@ fn test_generate_block_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -534,10 +535,10 @@ fn test_get_raw_transaction_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::from_stx_config(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .add_arg("-fallbackfee=0.0002") - .start_bitcoind_v2() + .start_bitcoind() .expect("bitcoind should be started!"); let client = BitcoinRpcClient::from_stx_config(&config).expect("Client creation ok!"); @@ -576,10 +577,10 @@ fn test_get_transaction_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::from_stx_config(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .add_arg("-fallbackfee=0.0002") - .start_bitcoind_v2() + .start_bitcoind() .expect("bitcoind should be started!"); let client = BitcoinRpcClient::from_stx_config(&config).expect("Client creation ok!"); @@ -614,9 +615,9 @@ fn test_get_descriptor_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::from_stx_config(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller - .start_bitcoind_v2() + .start_bitcoind() .expect("bitcoind should be started!"); let client = BitcoinRpcClient::from_stx_config(&config).expect("Client creation ok!"); @@ -644,9 +645,9 @@ fn test_import_descriptor_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::from_stx_config(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller - .start_bitcoind_v2() + .start_bitcoind() .expect("bitcoind should be started!"); let client = BitcoinRpcClient::from_stx_config(&config).expect("Client creation ok!"); @@ -679,7 +680,7 @@ fn test_stop_bitcoind_ok() { let config = utils::create_stx_config(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -699,7 +700,7 @@ fn test_invalidate_block_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -738,7 +739,7 @@ fn test_get_block_hash_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::new(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .start_bitcoind() .expect("bitcoind should be started!"); @@ -761,10 +762,10 @@ fn test_send_raw_transaction_rebroadcast_ok() { let mut config = utils::create_stx_config(); config.burnchain.wallet_name = "my_wallet".to_string(); - let mut btcd_controller = BitcoinCoreController::from_stx_config(config.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&config); btcd_controller .add_arg("-fallbackfee=0.0002") - .start_bitcoind_v2() + .start_bitcoind() .expect("bitcoind should be started!"); let client = BitcoinRpcClient::from_stx_config(&config).expect("Client creation ok!"); diff --git a/stacks-node/src/tests/epoch_205.rs b/stacks-node/src/tests/epoch_205.rs index 40912a7f83..32d9bf793a 100644 --- a/stacks-node/src/tests/epoch_205.rs +++ b/stacks-node/src/tests/epoch_205.rs @@ -24,7 +24,7 @@ use stacks_common::codec::StacksMessageCodec; use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, VRFSeed}; use stacks_common::util::hash::hex_bytes; -use crate::tests::bitcoin_regtest::BitcoinCoreController; +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::tests::neon_integrations::*; use crate::tests::{run_until_burnchain_height, select_transactions_where}; use crate::{neon, BitcoinRegtestController, BurnchainController, Keychain}; @@ -116,7 +116,7 @@ fn test_exact_block_costs() { &[EventKeyType::AnyEvent, EventKeyType::MinedBlocks], ); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -346,7 +346,7 @@ fn test_dynamic_db_method_costs() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -506,7 +506,7 @@ fn transition_empty_blocks() { let keychain = Keychain::default(conf.node.seed.clone()); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -774,7 +774,7 @@ fn test_cost_limit_switch_version205() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) diff --git a/stacks-node/src/tests/epoch_21.rs b/stacks-node/src/tests/epoch_21.rs index 8a4c4ef6cf..b742234001 100644 --- a/stacks-node/src/tests/epoch_21.rs +++ b/stacks-node/src/tests/epoch_21.rs @@ -36,13 +36,13 @@ use stacks_common::util::hash::{Hash160, Sha256Sum}; use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey}; use stacks_common::util::sleep_ms; +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::burnchains::bitcoin_regtest_controller::UTXO; use crate::neon::RunLoopCounter; use crate::operations::BurnchainOpSigner; use crate::stacks_common::address::AddressHashMode; use crate::stacks_common::types::Address; use crate::stacks_common::util::hash::{bytes_to_hex, hex_bytes}; -use crate::tests::bitcoin_regtest::BitcoinCoreController; use crate::tests::neon_integrations::*; use crate::tests::*; use crate::{neon, BitcoinRegtestController, BurnchainController, Keychain}; @@ -103,7 +103,7 @@ fn advance_to_2_1( )); burnchain_config.pox_constants = pox_constants; - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -602,7 +602,7 @@ fn transition_fixes_bitcoin_rigidity() { ); burnchain_config.pox_constants = pox_constants; - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -1480,7 +1480,7 @@ fn transition_removes_pox_sunset() { conf.burnchain.epochs = Some(epochs); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -1766,7 +1766,7 @@ fn transition_empty_blocks() { ); burnchain_config.pox_constants = pox_constants; - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -2120,7 +2120,7 @@ fn test_pox_reorgs_three_flaps() { burnchain_configs.push(burnchain_config); } - let mut btcd_controller = BitcoinCoreController::new(confs[0].clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&confs[0]); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -2638,7 +2638,7 @@ fn test_pox_reorg_one_flap() { burnchain_configs.push(burnchain_config); } - let mut btcd_controller = BitcoinCoreController::new(confs[0].clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&confs[0]); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -3045,7 +3045,7 @@ fn test_pox_reorg_flap_duel() { burnchain_configs.push(burnchain_config); } - let mut btcd_controller = BitcoinCoreController::new(confs[0].clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&confs[0]); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -3461,7 +3461,7 @@ fn test_pox_reorg_flap_reward_cycles() { burnchain_configs.push(burnchain_config); } - let mut btcd_controller = BitcoinCoreController::new(confs[0].clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&confs[0]); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -3871,7 +3871,7 @@ fn test_pox_missing_five_anchor_blocks() { burnchain_configs.push(burnchain_config); } - let mut btcd_controller = BitcoinCoreController::new(confs[0].clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&confs[0]); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -4253,7 +4253,7 @@ fn test_sortition_divergence_pre_21() { burnchain_configs.push(burnchain_config); } - let mut btcd_controller = BitcoinCoreController::new(confs[0].clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&confs[0]); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -4601,7 +4601,7 @@ fn trait_invocation_cross_epoch() { ); burnchain_config.pox_constants = pox_constants; - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -4864,7 +4864,7 @@ fn test_v1_unlock_height_with_current_stackers() { ); burnchain_config.pox_constants = pox_constants; - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -5117,7 +5117,7 @@ fn test_v1_unlock_height_with_delay_and_current_stackers() { ); burnchain_config.pox_constants = pox_constants; - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) diff --git a/stacks-node/src/tests/epoch_22.rs b/stacks-node/src/tests/epoch_22.rs index 3a9df900b9..a306b430f4 100644 --- a/stacks-node/src/tests/epoch_22.rs +++ b/stacks-node/src/tests/epoch_22.rs @@ -19,10 +19,10 @@ use stacks_common::util::secp256k1::Secp256k1PublicKey; use stacks_common::util::sleep_ms; use super::neon_integrations::get_account; +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::neon_node::StacksNode; use crate::stacks_common::types::Address; use crate::stacks_common::util::hash::bytes_to_hex; -use crate::tests::bitcoin_regtest::BitcoinCoreController; use crate::tests::epoch_21::wait_pox_stragglers; use crate::tests::neon_integrations::*; use crate::tests::*; @@ -153,7 +153,7 @@ fn disable_pox() { ); burnchain_config.pox_constants = pox_constants.clone(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -677,7 +677,7 @@ fn pox_2_unlock_all() { ); burnchain_config.pox_constants = pox_constants.clone(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -1375,7 +1375,7 @@ fn test_pox_reorg_one_flap() { burnchain_configs.push(burnchain_config); } - let mut btcd_controller = BitcoinCoreController::new(confs[0].clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&confs[0]); btcd_controller .start_bitcoind() .map_err(|_e| ()) diff --git a/stacks-node/src/tests/epoch_23.rs b/stacks-node/src/tests/epoch_23.rs index 43d436ddce..75b9cb5183 100644 --- a/stacks-node/src/tests/epoch_23.rs +++ b/stacks-node/src/tests/epoch_23.rs @@ -24,7 +24,7 @@ use stacks::core::test_util::make_contract_call; use stacks::core::{self, EpochList, STACKS_EPOCH_MAX}; use stacks_common::util::sleep_ms; -use crate::tests::bitcoin_regtest::BitcoinCoreController; +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::tests::neon_integrations::*; use crate::tests::*; use crate::{neon, BitcoinRegtestController, BurnchainController}; @@ -134,7 +134,7 @@ fn trait_invocation_behavior() { ); burnchain_config.pox_constants = pox_constants; - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) diff --git a/stacks-node/src/tests/epoch_24.rs b/stacks-node/src/tests/epoch_24.rs index 82b5c5f45e..d979fd2fee 100644 --- a/stacks-node/src/tests/epoch_24.rs +++ b/stacks-node/src/tests/epoch_24.rs @@ -37,8 +37,8 @@ use stacks_common::util::hash::{bytes_to_hex, hex_bytes, Hash160}; use stacks_common::util::secp256k1::Secp256k1PublicKey; use stacks_common::util::sleep_ms; +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::stacks_common::codec::StacksMessageCodec; -use crate::tests::bitcoin_regtest::BitcoinCoreController; use crate::tests::neon_integrations::{ get_account, get_chain_info, get_pox_info, neon_integration_test_conf, next_block_and_wait, submit_tx, test_observer, wait_for_runloop, @@ -175,7 +175,7 @@ fn fix_to_pox_contract() { ); burnchain_config.pox_constants = pox_constants.clone(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -803,7 +803,7 @@ fn verify_auto_unlock_behavior() { .unwrap() + 1; - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) diff --git a/stacks-node/src/tests/mod.rs b/stacks-node/src/tests/mod.rs index 6e35c9bb97..567eba245d 100644 --- a/stacks-node/src/tests/mod.rs +++ b/stacks-node/src/tests/mod.rs @@ -44,7 +44,7 @@ use crate::tests::neon_integrations::{get_chain_info, next_block_and_wait}; use crate::BitcoinRegtestController; mod atlas; -pub mod bitcoin_regtest; +mod bitcoin; mod bitcoin_rpc_integrations; mod epoch_205; mod epoch_21; diff --git a/stacks-node/src/tests/nakamoto_integrations.rs b/stacks-node/src/tests/nakamoto_integrations.rs index 6eb120f3a0..768b4686b3 100644 --- a/stacks-node/src/tests/nakamoto_integrations.rs +++ b/stacks-node/src/tests/nakamoto_integrations.rs @@ -114,7 +114,7 @@ use stacks_signer::chainstate::ProposalEvalConfig; use stacks_signer::signerdb::{BlockInfo, BlockState, ExtraBlockInfo, SignerDb}; use stacks_signer::v0::SpawnedSigner; -use super::bitcoin_regtest::BitcoinCoreController; +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::nakamoto_node::miner::{ fault_injection_stall_miner, fault_injection_unstall_miner, TEST_BLOCK_ANNOUNCE_STALL, TEST_BROADCAST_PROPOSAL_STALL, TEST_P2P_BROADCAST_SKIP, TEST_P2P_BROADCAST_STALL, @@ -1582,7 +1582,7 @@ fn simple_neon_integration() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -1807,7 +1807,7 @@ fn restarting_miner() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -2032,7 +2032,7 @@ fn flash_blocks_on_epoch_3_FLAKY() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -2279,7 +2279,7 @@ fn mine_multiple_per_tenure_integration() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -2494,7 +2494,7 @@ fn multiple_miners() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -2723,7 +2723,7 @@ fn correct_burn_outs() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3036,7 +3036,7 @@ fn block_proposal_api_endpoint() { test_observer::spawn(); test_observer::register(&mut conf, &[EventKeyType::BlockProposal]); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3413,7 +3413,7 @@ fn miner_writes_proposed_block_to_stackerdb() { &[EventKeyType::AnyEvent, EventKeyType::MinedBlocks], ); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3517,7 +3517,7 @@ fn vote_for_aggregate_key_burn_op() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3746,7 +3746,7 @@ fn follower_bootup_simple() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -4067,7 +4067,7 @@ fn follower_bootup_across_multiple_cycles() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -4294,7 +4294,7 @@ fn follower_bootup_custom_chain_id() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -4642,7 +4642,7 @@ fn burn_ops_integration_test() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -5229,7 +5229,7 @@ fn forked_tenure_is_ignored() { let miner_sk = naka_conf.miner.mining_key.clone().unwrap(); let miner_pk = StacksPublicKey::from_private(&miner_sk); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -5584,7 +5584,7 @@ fn check_block_heights() { let recipient = PrincipalData::from(StacksAddress::burn_address(false)); let stacker_sk = setup_stacker(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -6029,7 +6029,7 @@ fn nakamoto_attempt_time() { test_observer::spawn(); test_observer::register(&mut naka_conf, &[EventKeyType::BlockProposal]); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -6333,7 +6333,7 @@ fn clarity_burn_state() { test_observer::spawn(); test_observer::register(&mut naka_conf, &[EventKeyType::MinedBlocks]); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -6604,7 +6604,7 @@ fn signer_chainstate() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -7139,7 +7139,7 @@ fn continue_tenure_extend() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -7586,7 +7586,7 @@ fn check_block_times() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -7978,7 +7978,7 @@ fn check_block_info() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -8611,7 +8611,7 @@ fn check_block_info_rewards() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -8956,7 +8956,7 @@ fn mock_mining() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -9174,7 +9174,7 @@ fn utxo_check_on_startup_panic() { } last.start_height = 131; - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -9250,7 +9250,7 @@ fn utxo_check_on_startup_recover() { } last.start_height = 131; - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -9318,7 +9318,7 @@ fn v3_signer_api_endpoint() { test_observer::spawn(); test_observer::register(&mut conf, &[EventKeyType::BlockProposal]); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -9481,7 +9481,7 @@ fn v3_blockbyheight_api_endpoint() { test_observer::spawn(); test_observer::register(&mut conf, &[EventKeyType::BlockProposal]); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -9600,7 +9600,7 @@ fn nakamoto_lockup_events() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -9778,7 +9778,7 @@ fn skip_mining_long_tx() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -10140,7 +10140,7 @@ fn sip029_coinbase_change() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -10361,7 +10361,7 @@ fn clarity_cost_spend_down() { test_observer::spawn(); test_observer::register(&mut naka_conf, &[EventKeyType::MinedBlocks]); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -10622,7 +10622,7 @@ fn consensus_hash_event_dispatcher() { test_observer::spawn(); test_observer::register(&mut conf, &[EventKeyType::AnyEvent]); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -11063,7 +11063,7 @@ fn mine_invalid_principal_from_consensus_buff() { test_observer::spawn(); test_observer::register(&mut conf, &[EventKeyType::AnyEvent]); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -11182,7 +11182,7 @@ fn reload_miner_config() { test_observer::spawn(); test_observer::register(&mut conf, &[EventKeyType::AnyEvent]); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -11328,7 +11328,7 @@ fn rbf_on_config_change() { test_observer::spawn(); test_observer::register(&mut conf, &[EventKeyType::AnyEvent]); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -11508,7 +11508,7 @@ fn large_mempool_base(strategy: MemPoolWalkStrategy, set_fee: impl Fn() -> u64) naka_conf.node.working_dir ); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -11849,7 +11849,7 @@ fn larger_mempool() { naka_conf.node.working_dir ); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -12123,7 +12123,7 @@ fn v3_transaction_api_endpoint() { test_observer::spawn(); test_observer::register(&mut conf, &[EventKeyType::MinedBlocks]); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -12292,7 +12292,7 @@ fn handle_considered_txs_foreign_key_failure() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -12434,7 +12434,7 @@ fn empty_mempool_sleep_ms() { // see the effect in the test. conf.miner.empty_mempool_sleep_time = Duration::from_secs(30); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -12563,7 +12563,7 @@ fn miner_constructs_replay_block() { &[EventKeyType::AnyEvent, EventKeyType::MinedBlocks], ); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -12828,7 +12828,7 @@ fn test_sip_031_activation() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -13158,7 +13158,7 @@ fn test_sip_031_last_phase() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -13482,7 +13482,7 @@ fn test_sip_031_last_phase_out_of_epoch() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -13681,7 +13681,7 @@ fn test_sip_031_last_phase_coinbase_matches_activation() { test_observer::spawn(); test_observer::register_any(&mut naka_conf); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); diff --git a/stacks-node/src/tests/neon_integrations.rs b/stacks-node/src/tests/neon_integrations.rs index 1744993bf9..6adbeea23a 100644 --- a/stacks-node/src/tests/neon_integrations.rs +++ b/stacks-node/src/tests/neon_integrations.rs @@ -84,8 +84,8 @@ use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, sleep_ms}; use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _}; use tokio::net::{TcpListener, TcpStream}; -use super::bitcoin_regtest::BitcoinCoreController; use super::{ADDR_4, SK_1, SK_2, SK_3}; +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::burnchains::bitcoin_regtest_controller::{self, addr2str, BitcoinRPCRequest, UTXO}; use crate::neon_node::RelayerThread; use crate::operations::BurnchainOpSigner; @@ -1136,7 +1136,7 @@ fn bitcoind_integration_test() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -1244,7 +1244,7 @@ fn confirm_unparsed_ongoing_ops() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -1326,7 +1326,7 @@ fn most_recent_utxo_integration_test() { let (conf, _) = neon_integration_test_conf(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -1580,7 +1580,7 @@ fn deep_contract() { amount: spender_bal, }); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -1690,7 +1690,7 @@ fn liquid_ustx_integration() { amount: spender_bal, }); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -1821,7 +1821,7 @@ fn lockup_integration() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -1943,7 +1943,7 @@ fn stx_transfer_btc_integration_test() { amount: 100300, }); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -2192,7 +2192,7 @@ fn stx_delegate_btc_integration_test() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -2471,7 +2471,7 @@ fn stack_stx_burn_op_test() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -2868,7 +2868,7 @@ fn vote_for_aggregate_key_burn_op_test() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3116,7 +3116,7 @@ fn bitcoind_resubmission_test() { amount: 100300, }); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3234,7 +3234,7 @@ fn bitcoind_forking_test() { let (conf, miner_account) = neon_integration_test_conf(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3342,7 +3342,7 @@ fn download_err_in_btc_reorg() { conf.node.mine_microblocks = false; conf.burnchain.pox_reward_length = Some(1000); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3465,7 +3465,7 @@ fn should_fix_2771() { let (conf, _miner_account) = neon_integration_test_conf(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3574,7 +3574,7 @@ fn filter_low_fee_tx_integration_test() { }) .collect(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3663,7 +3663,7 @@ fn filter_long_runtime_tx_integration_test() { }) .collect(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3768,7 +3768,7 @@ fn miner_submit_twice() { // included 1 or more transaction, but they could have made a second attempt with // more transactions. - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -3877,7 +3877,7 @@ fn size_check_integration_test() { conf.miner.first_attempt_time_ms = i64::MAX as u64; conf.miner.subsequent_attempt_time_ms = i64::MAX as u64; - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -4002,7 +4002,7 @@ fn block_replay_integration_test() { test_observer::spawn(); test_observer::register_any(&mut conf); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -4143,7 +4143,7 @@ fn cost_voting_integration() { amount: spender_bal, }); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -4502,7 +4502,7 @@ fn mining_events_integration_test() { ], ); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .expect("Failed starting bitcoind"); @@ -4791,7 +4791,7 @@ fn setup_block_limit_test(strategy: MemPoolWalkStrategy) -> (Vec( node_config_modifier(&mut naka_conf); info!("Make new BitcoinCoreController"); - let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&naka_conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) diff --git a/stacks-node/src/tests/stackerdb.rs b/stacks-node/src/tests/stackerdb.rs index 6212dd6fcc..2fc840d4f5 100644 --- a/stacks-node/src/tests/stackerdb.rs +++ b/stacks-node/src/tests/stackerdb.rs @@ -24,7 +24,7 @@ use stacks_common::types::chainstate::StacksAddress; use stacks_common::util::hash::Sha512Trunc256Sum; use {reqwest, serde_json}; -use super::bitcoin_regtest::BitcoinCoreController; +use crate::burnchains::bitcoin::core_controller::BitcoinCoreController; use crate::burnchains::BurnchainController; use crate::tests::neon_integrations::{ neon_integration_test_conf, next_block_and_wait, submit_tx, test_observer, wait_for_runloop, @@ -163,7 +163,7 @@ fn test_stackerdb_load_store() { test_observer::spawn(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ()) @@ -300,7 +300,7 @@ fn test_stackerdb_event_observer() { test_observer::spawn(); - let mut btcd_controller = BitcoinCoreController::new(conf.clone()); + let mut btcd_controller = BitcoinCoreController::from_stx_config(&conf); btcd_controller .start_bitcoind() .map_err(|_e| ())