corepc_node/
lib.rs

1#![cfg_attr(docsrs, feature(doc_auto_cfg))]
2#![cfg_attr(feature = "doc", cfg_attr(all(), doc = include_str!("../README.md")))]
3
4pub extern crate corepc_client as client;
5
6#[rustfmt::skip]
7mod client_versions;
8mod versions;
9
10use std::ffi::OsStr;
11use std::net::{Ipv4Addr, SocketAddrV4, TcpListener};
12use std::path::PathBuf;
13use std::process::{Child, Command, ExitStatus, Stdio};
14use std::time::Duration;
15use std::{env, fmt, fs, thread};
16
17use anyhow::Context;
18use corepc_client::client_sync::{self, Auth};
19use log::{debug, error, warn};
20use tempfile::TempDir;
21pub use {anyhow, serde_json, tempfile, which};
22
23#[rustfmt::skip]                // Keep pubic re-exports separate.
24#[doc(inline)]
25pub use self::{
26    client_versions::{types, Client, AddressType},
27    versions::VERSION,
28};
29
30#[derive(Debug)]
31/// Struct representing the bitcoind process with related information
32pub struct Node {
33    /// Process child handle, used to terminate the process when this struct is dropped
34    process: Child,
35    /// Rpc client linked to this bitcoind process
36    pub client: Client,
37    /// Work directory, where the node store blocks and other stuff.
38    work_dir: DataDir,
39
40    /// Contains information to connect to this node
41    pub params: ConnectParams,
42}
43
44#[derive(Debug)]
45/// The DataDir struct defining the kind of data directory the node
46/// will contain. Data directory can be either persistent, or temporary.
47pub enum DataDir {
48    /// Persistent Data Directory
49    Persistent(PathBuf),
50    /// Temporary Data Directory
51    Temporary(TempDir),
52}
53
54impl DataDir {
55    /// Return the data directory path
56    fn path(&self) -> PathBuf {
57        match self {
58            Self::Persistent(path) => path.to_owned(),
59            Self::Temporary(tmp_dir) => tmp_dir.path().to_path_buf(),
60        }
61    }
62}
63
64#[derive(Debug, Clone)]
65/// Contains all the information to connect to this node
66pub struct ConnectParams {
67    /// Path to the node cookie file, useful for other client to connect to the node
68    pub cookie_file: PathBuf,
69    /// Url of the rpc of the node, useful for other client to connect to the node
70    pub rpc_socket: SocketAddrV4,
71    /// p2p connection url, is some if the node started with p2p enabled
72    pub p2p_socket: Option<SocketAddrV4>,
73    /// zmq pub raw block connection url
74    pub zmq_pub_raw_block_socket: Option<SocketAddrV4>,
75    /// zmq pub raw tx connection Url
76    pub zmq_pub_raw_tx_socket: Option<SocketAddrV4>,
77}
78
79pub struct CookieValues {
80    pub user: String,
81    pub password: String,
82}
83
84impl ConnectParams {
85    /// Parses the cookie file content
86    fn parse_cookie(content: String) -> Option<CookieValues> {
87        let values: Vec<_> = content.splitn(2, ':').collect();
88        let user = values.first()?.to_string();
89        let password = values.get(1)?.to_string();
90        Some(CookieValues { user, password })
91    }
92
93    /// Return the user and password values from cookie file
94    pub fn get_cookie_values(&self) -> Result<Option<CookieValues>, std::io::Error> {
95        let cookie = std::fs::read_to_string(&self.cookie_file)?;
96        Ok(self::ConnectParams::parse_cookie(cookie))
97    }
98}
99
100/// Enum to specify p2p settings
101#[derive(Debug, PartialEq, Eq, Clone)]
102pub enum P2P {
103    /// the node doesn't open a p2p port and work in standalone mode
104    No,
105    /// the node open a p2p port
106    Yes,
107    /// The node open a p2p port and also connects to the url given as parameter, it's handy to
108    /// initialize this with [Node::p2p_connect] of another node. The `bool` parameter indicates
109    /// if the node can accept connection too.
110    Connect(SocketAddrV4, bool),
111}
112
113/// All the possible error in this crate
114pub enum Error {
115    /// Wrapper of io Error
116    Io(std::io::Error),
117    /// Wrapper of bitcoincore_rpc Error
118    Rpc(client_sync::Error),
119    /// Returned when calling methods requiring a feature to be activated, but it's not
120    NoFeature,
121    /// Returned when calling methods requiring a env var to exist, but it's not
122    NoEnvVar,
123    /// Returned when calling methods requiring the bitcoind executable but none is found
124    /// (no feature, no `BITCOIND_EXE`, no `bitcoind` in `PATH` )
125    NoBitcoindExecutableFound,
126    /// Wrapper of early exit status
127    EarlyExit(ExitStatus),
128    /// Returned when both tmpdir and staticdir is specified in `Conf` options
129    BothDirsSpecified,
130    /// Returned when -rpcuser and/or -rpcpassword is used in `Conf` args
131    /// It will soon be deprecated, please use -rpcauth instead
132    RpcUserAndPasswordUsed,
133    /// Returned when expecting an auto-downloaded executable but `BITCOIND_SKIP_DOWNLOAD` env var is set
134    SkipDownload,
135    /// It appears that bitcoind is not reachable.
136    NoBitcoindInstance,
137}
138
139impl fmt::Debug for Error {
140    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
141        use Error::*;
142
143        match self {
144            Io(_) => write!(f, "io::Error"), // FIXME: Use bitcoin-internals.
145            Rpc(_) => write!(f, "bitcoin_rpc::Error"),
146            NoFeature => write!(f, "Called a method requiring a feature to be set, but it's not"),
147            NoEnvVar => write!(f, "Called a method requiring env var `BITCOIND_EXE` to be set, but it's not"),
148            NoBitcoindExecutableFound =>  write!(f, "`bitcoind` executable is required, provide it with one of the following: set env var `BITCOIND_EXE` or use a feature like \"22_1\" or have `bitcoind` executable in the `PATH`"),
149            EarlyExit(e) => write!(f, "The bitcoind process terminated early with exit code {}", e),
150            BothDirsSpecified => write!(f, "tempdir and staticdir cannot be enabled at same time in configuration options"),
151            RpcUserAndPasswordUsed => write!(f, "`-rpcuser` and `-rpcpassword` cannot be used, it will be deprecated soon and it's recommended to use `-rpcauth` instead which works alongside with the default cookie authentication"),
152            SkipDownload => write!(f, "expecting an auto-downloaded executable but `BITCOIND_SKIP_DOWNLOAD` env var is set"),
153            NoBitcoindInstance => write!(f, "it appears that bitcoind is not reachable"),
154        }
155    }
156}
157
158impl std::fmt::Display for Error {
159    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{:?}", self) }
160}
161
162impl std::error::Error for Error {
163    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
164        use Error::*;
165
166        match *self {
167            Error::Io(ref e) => Some(e),
168            Error::Rpc(ref e) => Some(e),
169            NoFeature
170            | NoEnvVar
171            | NoBitcoindExecutableFound
172            | EarlyExit(_)
173            | BothDirsSpecified
174            | RpcUserAndPasswordUsed
175            | SkipDownload
176            | NoBitcoindInstance => None,
177        }
178    }
179}
180
181const LOCAL_IP: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);
182
183const INVALID_ARGS: [&str; 2] = ["-rpcuser", "-rpcpassword"];
184
185/// The node configuration parameters, implements a convenient [Default] for most common use.
186///
187/// `#[non_exhaustive]` allows adding new parameters without breaking downstream users.
188/// Users cannot instantiate the struct directly, they need to create it via the `default()` method
189/// and mutate fields according to their preference.
190///
191/// Default values:
192/// ```
193/// use corepc_node as bitcoind;
194/// let mut conf = bitcoind::Conf::default();
195/// conf.args = vec!["-regtest", "-fallbackfee=0.0001"];
196/// conf.view_stdout = false;
197/// conf.p2p = bitcoind::P2P::No;
198/// conf.network = "regtest";
199/// conf.tmpdir = None;
200/// conf.staticdir = None;
201/// conf.attempts = 3;
202/// assert_eq!(conf, bitcoind::Conf::default());
203/// ```
204///
205#[non_exhaustive]
206#[derive(Debug, PartialEq, Eq, Clone)]
207pub struct Conf<'a> {
208    /// Bitcoind command line arguments containing no spaces like `vec!["-dbcache=300", "-regtest"]`
209    /// note that `port`, `rpcport`, `connect`, `datadir`, `listen`
210    /// cannot be used because they are automatically initialized.
211    pub args: Vec<&'a str>,
212
213    /// if `true` bitcoind log output will not be suppressed
214    pub view_stdout: bool,
215
216    /// Allows to specify options to open p2p port or connect to the another node
217    pub p2p: P2P,
218
219    /// Must match what specified in args without dashes, needed to locate the cookie file
220    /// directory with different/esoteric networks
221    pub network: &'a str,
222
223    /// Optionally specify a temporary or persistent working directory for the node.
224    /// The following two parameters can be configured to simulate desired working directory configuration.
225    ///
226    /// tmpdir is Some() && staticdir is Some() : Error. Cannot be enabled at same time.
227    /// tmpdir is Some(temp_path) && staticdir is None : Create temporary directory at `tmpdir` path.
228    /// tmpdir is None && staticdir is Some(work_path) : Create persistent directory at `staticdir` path.
229    /// tmpdir is None && staticdir is None: Creates a temporary directory in OS default temporary directory (eg /tmp) or `TEMPDIR_ROOT` env variable path.
230    ///
231    /// It may be useful for example to set to a ramdisk via `TEMPDIR_ROOT` env option so that
232    /// bitcoin nodes spawn very fast because their datadirs are in RAM. Should not be enabled with persistent
233    /// mode, as it cause memory overflows.
234
235    /// Temporary directory path
236    pub tmpdir: Option<PathBuf>,
237
238    /// Persistent directory path
239    pub staticdir: Option<PathBuf>,
240
241    /// Try to spawn the process `attempt` time
242    ///
243    /// The OS is giving available ports to use, however, they aren't booked, so it could rarely
244    /// happen they are used at the time the process is spawn. When retrying other available ports
245    /// are returned reducing the probability of conflicts to negligible.
246    pub attempts: u8,
247
248    /// Enable the ZMQ interface to be accessible.
249    pub enable_zmq: bool,
250
251    /// Load `wallet` after initialization.
252    pub wallet: Option<String>,
253}
254
255impl Default for Conf<'_> {
256    fn default() -> Self {
257        Conf {
258            args: vec!["-regtest", "-fallbackfee=0.0001"],
259            view_stdout: false,
260            p2p: P2P::No,
261            network: "regtest",
262            tmpdir: None,
263            staticdir: None,
264            attempts: 3,
265            enable_zmq: false,
266            wallet: Some("default".to_string()),
267        }
268    }
269}
270
271impl Node {
272    /// Launch the bitcoind process from the given `exe` executable with default args.
273    ///
274    /// Waits for the node to be ready to accept connections before returning
275    pub fn new<S: AsRef<OsStr>>(exe: S) -> anyhow::Result<Node> {
276        Node::with_conf(exe, &Conf::default())
277    }
278
279    /// Launch the bitcoind process from the given `exe` executable with given [Conf] param and create/load the "default" wallet.
280    pub fn with_conf<S: AsRef<OsStr>>(exe: S, conf: &Conf) -> anyhow::Result<Node> {
281        let tmpdir =
282            conf.tmpdir.clone().or_else(|| env::var("TEMPDIR_ROOT").map(PathBuf::from).ok());
283        let work_dir = match (&tmpdir, &conf.staticdir) {
284            (Some(_), Some(_)) => return Err(Error::BothDirsSpecified.into()),
285            (Some(tmpdir), None) => DataDir::Temporary(TempDir::new_in(tmpdir)?),
286            (None, Some(workdir)) => {
287                fs::create_dir_all(workdir)?;
288                DataDir::Persistent(workdir.to_owned())
289            }
290            (None, None) => DataDir::Temporary(TempDir::new()?),
291        };
292
293        let work_dir_path = work_dir.path();
294        if !work_dir_path.exists() {
295            panic!("work dir does not exist");
296        }
297        debug!("work_dir: {:?}", work_dir_path);
298
299        let cookie_file = work_dir_path.join(conf.network).join(".cookie");
300        let rpc_port = get_available_port()?;
301        let rpc_socket = SocketAddrV4::new(LOCAL_IP, rpc_port);
302        let rpc_url = format!("http://{}", rpc_socket);
303        debug!("rpc_url: {}", rpc_url);
304
305        let (p2p_args, p2p_socket) = match conf.p2p {
306            P2P::No => (vec!["-listen=0".to_string()], None),
307            P2P::Yes => {
308                let p2p_port = get_available_port()?;
309                let p2p_socket = SocketAddrV4::new(LOCAL_IP, p2p_port);
310                let p2p_arg = format!("-port={}", p2p_port);
311                let args = vec![p2p_arg];
312                (args, Some(p2p_socket))
313            }
314            P2P::Connect(other_node_url, listen) => {
315                let p2p_port = get_available_port()?;
316                let p2p_socket = SocketAddrV4::new(LOCAL_IP, p2p_port);
317                let p2p_arg = format!("-port={}", p2p_port);
318                let connect = format!("-connect={}", other_node_url);
319                let mut args = vec![p2p_arg, connect];
320                if listen {
321                    args.push("-listen=1".to_string())
322                }
323                (args, Some(p2p_socket))
324            }
325        };
326
327        let (zmq_args, zmq_pub_raw_tx_socket, zmq_pub_raw_block_socket) = match conf.enable_zmq {
328            true => {
329                let zmq_pub_raw_tx_port = get_available_port()?;
330                let zmq_pub_raw_tx_socket = SocketAddrV4::new(LOCAL_IP, zmq_pub_raw_tx_port);
331                let zmq_pub_raw_block_port = get_available_port()?;
332                let zmq_pub_raw_block_socket = SocketAddrV4::new(LOCAL_IP, zmq_pub_raw_block_port);
333                let zmqpubrawblock_arg =
334                    format!("-zmqpubrawblock=tcp://0.0.0.0:{}", zmq_pub_raw_block_port);
335                let zmqpubrawtx_arg = format!("-zmqpubrawtx=tcp://0.0.0.0:{}", zmq_pub_raw_tx_port);
336                (
337                    vec![zmqpubrawtx_arg, zmqpubrawblock_arg],
338                    Some(zmq_pub_raw_tx_socket),
339                    Some(zmq_pub_raw_block_socket),
340                )
341            }
342            false => (vec![], None, None),
343        };
344
345        let stdout = if conf.view_stdout { Stdio::inherit() } else { Stdio::null() };
346
347        let datadir_arg = format!("-datadir={}", work_dir_path.display());
348        let rpc_arg = format!("-rpcport={}", rpc_port);
349        let default_args = [&datadir_arg, &rpc_arg];
350        let conf_args = validate_args(conf.args.clone())?;
351
352        debug!(
353            "launching {:?} with args: {:?} {:?} AND custom args: {:?}",
354            exe.as_ref(),
355            default_args,
356            p2p_args,
357            conf_args
358        );
359
360        let mut process = Command::new(exe.as_ref())
361            .args(default_args)
362            .args(&p2p_args)
363            .args(&conf_args)
364            .args(&zmq_args)
365            .stdout(stdout)
366            .spawn()
367            .with_context(|| format!("Error while executing {:?}", exe.as_ref()))?;
368
369        debug!("cookie file: {}", cookie_file.display());
370
371        if let Some(status) = process.try_wait()? {
372            if conf.attempts > 0 {
373                warn!("early exit with: {:?}. Trying to launch again ({} attempts remaining), maybe some other process used our available port", status, conf.attempts);
374                let mut conf = conf.clone();
375                conf.attempts -= 1;
376                return Self::with_conf(exe, &conf)
377                    .with_context(|| format!("Remaining attempts {}", conf.attempts));
378            } else {
379                error!("early exit with: {:?}", status);
380                return Err(Error::EarlyExit(status).into());
381            }
382        }
383        thread::sleep(Duration::from_millis(1000));
384        assert!(process.stderr.is_none());
385
386        let mut i = 0;
387        let auth = Auth::CookieFile(cookie_file.clone());
388        let client_base =
389            Client::new_with_auth(&rpc_url, auth.clone()).expect("failed to create client");
390
391        let client = loop {
392            // Just use serde value because changes to the GetBlockchainInfo type make debugging hard.
393            let client_result: Result<serde_json::Value, _> =
394                client_base.call("getblockchaininfo", &[]);
395
396            if client_result.is_ok() {
397                let url = match &conf.wallet {
398                    Some(wallet) => {
399                        debug!("trying to create/load wallet: {}", wallet);
400                        // Debugging logic here implicitly tests `into_model` for create/load wallet.
401                        match client_base.create_wallet(wallet) {
402                            Ok(json) => {
403                                debug!("created wallet: {}", json.name());
404                            },
405                            Err(e) => {
406                                debug!("initial create_wallet unsuccessful, try loading instead: {:?}", e);
407                                let wallet = client_base.load_wallet(wallet)?.name();
408                                debug!("loaded wallet: {}", wallet);
409                            }
410                        }
411                        format!("{}/wallet/{}", rpc_url, wallet)
412                    }
413                    None => rpc_url,
414                };
415                debug!("creating client with url: {}", url);
416                break Client::new_with_auth(&url, auth)?;
417            }
418
419            thread::sleep(Duration::from_millis(1000));
420
421            i += 1;
422            if i > 10 {
423                error!("failed to get a response from bitcoind");
424                return Err(Error::NoBitcoindInstance.into());
425            }
426        };
427
428        Ok(Node {
429            process,
430            client,
431            work_dir,
432            params: ConnectParams {
433                cookie_file,
434                rpc_socket,
435                p2p_socket,
436                zmq_pub_raw_block_socket,
437                zmq_pub_raw_tx_socket,
438            },
439        })
440    }
441
442    /// Returns the rpc URL including the schema eg. http://127.0.0.1:44842
443    pub fn rpc_url(&self) -> String { format!("http://{}", self.params.rpc_socket) }
444
445    #[cfg(any(feature = "0_19_1", not(feature = "download")))]
446    /// Returns the rpc URL including the schema and the given `wallet_name`
447    /// eg. http://127.0.0.1:44842/wallet/my_wallet
448    pub fn rpc_url_with_wallet<T: AsRef<str>>(&self, wallet_name: T) -> String {
449        format!("http://{}/wallet/{}", self.params.rpc_socket, wallet_name.as_ref())
450    }
451
452    /// Return the current workdir path of the running node
453    pub fn workdir(&self) -> PathBuf { self.work_dir.path() }
454
455    /// Returns the [P2P] enum to connect to this node p2p port
456    pub fn p2p_connect(&self, listen: bool) -> Option<P2P> {
457        self.params.p2p_socket.map(|s| P2P::Connect(s, listen))
458    }
459
460    /// Stop the node, waiting correct process termination
461    pub fn stop(&mut self) -> anyhow::Result<ExitStatus> {
462        self.client.stop()?;
463        Ok(self.process.wait()?)
464    }
465
466    #[cfg(any(feature = "0_19_1", not(feature = "download")))]
467    /// Create a new wallet in the running node, and return an RPC client connected to the just
468    /// created wallet
469    pub fn create_wallet<T: AsRef<str>>(&self, wallet: T) -> anyhow::Result<Client> {
470        let _ = self.client.create_wallet(wallet.as_ref())?;
471        Ok(Client::new_with_auth(
472            &self.rpc_url_with_wallet(wallet),
473            Auth::CookieFile(self.params.cookie_file.clone()),
474        )?)
475    }
476}
477
478#[cfg(feature = "download")]
479impl Node {
480    /// create Node struct with the downloaded executable.
481    pub fn from_downloaded() -> anyhow::Result<Node> { Node::new(downloaded_exe_path()?) }
482
483    /// create Node struct with the downloaded executable and given Conf.
484    pub fn from_downloaded_with_conf(conf: &Conf) -> anyhow::Result<Node> {
485        Node::with_conf(downloaded_exe_path()?, conf)
486    }
487}
488
489impl Drop for Node {
490    fn drop(&mut self) {
491        if let DataDir::Persistent(_) = self.work_dir {
492            let _ = self.stop();
493        }
494        let _ = self.process.kill();
495    }
496}
497
498/// Returns a non-used local port if available.
499///
500/// Note there is a race condition during the time the method check availability and the caller
501pub fn get_available_port() -> anyhow::Result<u16> {
502    // using 0 as port let the system assign a port available
503    let t = TcpListener::bind(("127.0.0.1", 0))?; // 0 means the OS choose a free port
504    Ok(t.local_addr().map(|s| s.port())?)
505}
506
507impl From<std::io::Error> for Error {
508    fn from(e: std::io::Error) -> Self { Error::Io(e) }
509}
510
511impl From<client_sync::Error> for Error {
512    fn from(e: client_sync::Error) -> Self { Error::Rpc(e) }
513}
514
515/// Provide the bitcoind executable path if a version feature has been specified
516#[cfg(not(feature = "download"))]
517pub fn downloaded_exe_path() -> anyhow::Result<String> { Err(Error::NoFeature.into()) }
518
519/// Provide the bitcoind executable path if a version feature has been specified
520#[cfg(feature = "download")]
521pub fn downloaded_exe_path() -> anyhow::Result<String> {
522    if std::env::var_os("BITCOIND_SKIP_DOWNLOAD").is_some() {
523        return Err(Error::SkipDownload.into());
524    }
525
526    let mut path: PathBuf = env!("OUT_DIR").into();
527    path.push("bitcoin");
528    path.push(format!("bitcoin-{}", VERSION));
529    path.push("bin");
530
531    if cfg!(target_os = "windows") {
532        path.push("bitcoind.exe");
533    } else {
534        path.push("bitcoind");
535    }
536
537    let path = format!("{}", path.display());
538    debug!("path: {}", path);
539    Ok(path)
540}
541
542/// Returns the daemon `bitcoind` executable with the following precedence:
543///
544/// 1) If it's specified in the `BITCOIND_EXE` env var
545/// 2) If there is no env var but an auto-download feature such as `23_1` is enabled, returns the
546///    path of the downloaded executabled
547/// 3) If neither of the precedent are available, the `bitcoind` executable is searched in the `PATH`
548pub fn exe_path() -> anyhow::Result<String> {
549    if let Ok(path) = std::env::var("BITCOIND_EXE") {
550        return Ok(path);
551    }
552    if let Ok(path) = downloaded_exe_path() {
553        return Ok(path);
554    }
555    which::which("bitcoind")
556        .map_err(|_| Error::NoBitcoindExecutableFound.into())
557        .map(|p| p.display().to_string())
558}
559
560/// Validate the specified arg if there is any unavailable or deprecated one
561pub fn validate_args(args: Vec<&str>) -> anyhow::Result<Vec<&str>> {
562    args.iter().try_for_each(|arg| {
563        // other kind of invalid arguments can be added into the list if needed
564        if INVALID_ARGS.iter().any(|x| arg.starts_with(x)) {
565            return Err(Error::RpcUserAndPasswordUsed);
566        }
567        Ok(())
568    })?;
569
570    Ok(args)
571}
572
573#[cfg(test)]
574mod test {
575    use std::net::SocketAddrV4;
576
577    use tempfile::TempDir;
578
579    use super::*;
580    use crate::{exe_path, get_available_port, Node, Conf, LOCAL_IP};
581    #[cfg(not(feature = "28_0"))]
582    use crate::P2P;
583
584    #[test]
585    fn test_local_ip() {
586        assert_eq!("127.0.0.1", format!("{}", LOCAL_IP));
587        let port = get_available_port().unwrap();
588        let socket = SocketAddrV4::new(LOCAL_IP, port);
589        assert_eq!(format!("127.0.0.1:{}", port), format!("{}", socket));
590    }
591
592    #[test]
593    fn test_node_get_blockchain_info() {
594        let exe = init();
595        let node = Node::new(exe).unwrap();
596        let info = node.client.get_blockchain_info().unwrap();
597        assert_eq!(0, info.blocks);
598    }
599
600    #[test]
601    fn test_node() {
602        let exe = init();
603        let node = Node::new(exe).unwrap();
604        let info = node.client.get_blockchain_info().unwrap();
605
606        assert_eq!(0, info.blocks);
607        let address = node.client.new_address().unwrap();
608        let _ = node.client.generate_to_address(1, &address).unwrap();
609        let info = node.client.get_blockchain_info().unwrap();
610        assert_eq!(1, info.blocks);
611    }
612
613    #[test]
614    #[cfg(feature = "0_21_2")]
615    fn test_getindexinfo() {
616        let exe = init();
617        let mut conf = Conf::default();
618        conf.args.push("-txindex");
619        let node = Node::with_conf(&exe, &conf).unwrap();
620        assert!(
621            node.client.server_version().unwrap() >= 210_000,
622            "getindexinfo requires bitcoin >0.21"
623        );
624        let info: std::collections::HashMap<String, serde_json::Value> =
625            node.client.call("getindexinfo", &[]).unwrap();
626        assert!(info.contains_key("txindex"));
627        assert!(node.client.server_version().unwrap() >= 210_000);
628    }
629
630    #[test]
631    // When this test is run at the same time as `test_multi_p2p` for v28 it fails.
632    // FIXME: Debug this failure - test runs ok on its own.
633    #[cfg(not(feature = "28_0"))]
634    fn test_p2p() {
635        let exe = init();
636
637        let conf = Conf::<'_> { p2p: P2P::Yes, ..Default::default() };
638        let node = Node::with_conf(&exe, &conf).unwrap();
639        assert_eq!(peers_connected(&node.client), 0);
640
641        let other_conf = Conf::<'_> { p2p: node.p2p_connect(false).unwrap(), ..Default::default() };
642        let other_node = Node::with_conf(&exe, &other_conf).unwrap();
643
644        assert_eq!(peers_connected(&node.client), 1);
645        assert_eq!(peers_connected(&other_node.client), 1);
646    }
647
648    #[cfg(not(target_os = "windows"))] // TODO: investigate why it doesn't work in windows
649    #[test]
650    fn test_data_persistence() {
651        // Create a Conf with staticdir type
652        let mut conf = Conf::default();
653        let datadir = TempDir::new().unwrap();
654        conf.staticdir = Some(datadir.path().to_path_buf());
655
656        // Start Node with persistent db config
657        // Generate 101 blocks
658        // Wallet balance should be 50
659        let node = Node::with_conf(exe_path().unwrap(), &conf).unwrap();
660        let core_addrs = node.client.new_address().unwrap();
661        node.client.generate_to_address(101, &core_addrs).unwrap();
662        let wallet_balance_1 = node.client.get_balance().unwrap();
663        let best_block_1 = node.client.get_best_block_hash().unwrap();
664
665        drop(node);
666
667        // Start a new Node with the same datadir
668        let node = Node::with_conf(exe_path().unwrap(), &conf).unwrap();
669
670        let wallet_balance_2 = node.client.get_balance().unwrap();
671        let best_block_2 = node.client.get_best_block_hash().unwrap();
672
673        // Check node chain data persists
674        assert_eq!(best_block_1, best_block_2);
675
676        // Check the node wallet balance persists
677        assert_eq!(wallet_balance_1, wallet_balance_2);
678    }
679
680    #[test]
681    // In v28:
682    //
683    // > Bitcoin Core will now fail to start up if any of its P2P binds fail, rather than the
684    // > previous behaviour where it would only abort startup if all P2P binds had failed.
685    //
686    // ref: https://bitcoincore.org/en/releases/28.0/
687    // ref: https://github.com/bitcoin/bitcoin/pull/22729
688    //
689    // I tried various things to stop bitcoind attempting to bind on 18445 but could get nothing to work.
690    //
691    // - Tried using arg `-torcontrol=0`.
692    // - Tried using arg `-listenonion=0`.
693    // - Tried using arg `-bind={available_port}`.
694    // - Tried using arg `-bind={available_port}=onion`.
695    // - Tried using both the two bind args above together.
696    #[cfg(not(feature = "28_0"))]
697    fn test_multi_p2p() {
698        let exe = init();
699
700        let conf_node1 = Conf::<'_> { p2p: P2P::Yes, ..Default::default() };
701        let node1 = Node::with_conf(&exe, &conf_node1).unwrap();
702        assert_eq!(peers_connected(&node1.client), 0);
703
704        // Create Node 2 connected Node 1
705        let conf_node2 = Conf::<'_> { p2p: node1.p2p_connect(true).unwrap(), ..Default::default() };
706        let node2 = Node::with_conf(&exe, &conf_node2).unwrap();
707
708        // Create Node 3 Connected To Node
709        let conf_node3 = Conf::<'_> { p2p: node2.p2p_connect(false).unwrap(), ..Default::default() };
710        let node3 = Node::with_conf(exe_path().unwrap(), &conf_node3).unwrap();
711
712        // Get each nodes Peers
713        let node1_peers = peers_connected(&node1.client);
714        let node2_peers = peers_connected(&node2.client);
715        let node3_peers = peers_connected(&node3.client);
716
717        // Peers found
718        assert!(node1_peers >= 1);
719        assert!(node2_peers >= 1);
720        assert_eq!(node3_peers, 1, "listen false but more than 1 peer");
721    }
722
723    #[cfg(any(feature = "0_19_1", not(feature = "download")))]
724    #[test]
725    fn test_multi_wallet() {
726        use corepc_client::bitcoin::Amount;
727
728        let exe = init();
729        let node = Node::new(exe).unwrap();
730        let alice = node.create_wallet("alice").unwrap();
731        let alice_address = alice.new_address().unwrap();
732        let bob = node.create_wallet("bob").unwrap();
733        let bob_address = bob.new_address().unwrap();
734        node.client.generate_to_address(1, &alice_address).unwrap();
735        node.client.generate_to_address(101, &bob_address).unwrap();
736
737        let balances = alice.get_balances().unwrap();
738        let alice_balances: types::GetBalances = balances;
739
740        let balances = bob.get_balances().unwrap();
741        let bob_balances: types::GetBalances = balances;
742
743        assert_eq!(
744            Amount::from_btc(50.0).unwrap(),
745            Amount::from_btc(alice_balances.mine.trusted).unwrap()
746        );
747        assert_eq!(
748            Amount::from_btc(50.0).unwrap(),
749            Amount::from_btc(bob_balances.mine.trusted).unwrap()
750        );
751        assert_eq!(
752            Amount::from_btc(5000.0).unwrap(),
753            Amount::from_btc(bob_balances.mine.immature).unwrap()
754        );
755        let _txid = alice.send_to_address(&bob_address, Amount::from_btc(1.0).unwrap()).unwrap();
756
757        let balances = alice.get_balances().unwrap();
758        let alice_balances: types::GetBalances = balances;
759
760        assert!(
761            Amount::from_btc(alice_balances.mine.trusted).unwrap()
762                < Amount::from_btc(49.0).unwrap()
763                && Amount::from_btc(alice_balances.mine.trusted).unwrap()
764                    > Amount::from_btc(48.9).unwrap()
765        );
766
767        // bob wallet may not be immediately updated
768        for _ in 0..30 {
769            let balances = bob.get_balances().unwrap();
770            let bob_balances: types::GetBalances = balances;
771
772            if Amount::from_btc(bob_balances.mine.untrusted_pending).unwrap().to_sat() > 0 {
773                break;
774            }
775            std::thread::sleep(std::time::Duration::from_millis(100));
776        }
777        let balances = bob.get_balances().unwrap();
778        let bob_balances: types::GetBalances = balances;
779
780        assert_eq!(
781            Amount::from_btc(1.0).unwrap(),
782            Amount::from_btc(bob_balances.mine.untrusted_pending).unwrap()
783        );
784        assert!(node.create_wallet("bob").is_err(), "wallet already exist");
785    }
786
787    #[test]
788    fn test_node_rpcuser_and_rpcpassword() {
789        let exe = init();
790
791        let mut conf = Conf::default();
792        conf.args.push("-rpcuser=bitcoind");
793        conf.args.push("-rpcpassword=bitcoind");
794
795        let node = Node::with_conf(exe, &conf);
796
797        assert!(node.is_err());
798    }
799
800    #[test]
801    fn test_node_rpcauth() {
802        let exe = init();
803
804        let mut conf = Conf::default();
805        // rpcauth generated with [rpcauth.py](https://github.com/bitcoin/bitcoin/blob/master/share/rpcauth/rpcauth.py)
806        // this could be also added to node, example: [RpcAuth](https://github.com/testcontainers/testcontainers-rs/blob/dev/testcontainers/src/images/coblox_bitcoincore.rs#L39-L91)
807        conf.args.push("-rpcauth=bitcoind:cccd5d7fd36e55c1b8576b8077dc1b83$60b5676a09f8518dcb4574838fb86f37700cd690d99bd2fdc2ea2bf2ab80ead6");
808
809        let node = Node::with_conf(exe, &conf).unwrap();
810
811        let auth = Auth::UserPass("bitcoind".to_string(), "bitcoind".to_string());
812        let client = Client::new_with_auth(
813            format!("{}/wallet/default", node.rpc_url().as_str()).as_str(),
814            auth,
815        )
816        .unwrap();
817        let info = client.get_blockchain_info().unwrap();
818        assert_eq!(0, info.blocks);
819
820        let address = client.new_address().unwrap();
821        let _ = client.generate_to_address(1, &address).unwrap();
822        let info = node.client.get_blockchain_info().unwrap();
823        assert_eq!(1, info.blocks);
824    }
825
826    #[test]
827    fn test_get_cookie_user_and_pass() {
828        let exe = init();
829        let node = Node::new(exe).unwrap();
830
831        let user: &str = "bitcoind_user";
832        let password: &str = "bitcoind_password";
833
834        std::fs::write(&node.params.cookie_file, format!("{}:{}", user, password)).unwrap();
835
836        let result_values = node.params.get_cookie_values().unwrap().unwrap();
837
838        assert_eq!(user, result_values.user);
839        assert_eq!(password, result_values.password);
840    }
841
842    #[test]
843    fn zmq_interface_enabled() {
844        let conf = Conf::<'_> { enable_zmq: true, ..Default::default() };
845        let node = Node::with_conf(exe_path().unwrap(), &conf).unwrap();
846
847        assert!(node.params.zmq_pub_raw_tx_socket.is_some());
848        assert!(node.params.zmq_pub_raw_block_socket.is_some());
849    }
850
851    #[test]
852    fn zmq_interface_disabled() {
853        let exe = init();
854        let node = Node::new(exe).unwrap();
855
856        assert!(node.params.zmq_pub_raw_tx_socket.is_none());
857        assert!(node.params.zmq_pub_raw_block_socket.is_none());
858    }
859
860    #[cfg(not(feature = "28_0"))]
861    fn peers_connected(client: &Client) -> usize {
862        // FIXME: Once client implements get_peer_info use it.
863        // This is kinda cool, it shows we can call any RPC method using the client.
864        let result: Vec<serde_json::Value> = client.call("getpeerinfo", &[]).unwrap();
865        result.len()
866    }
867
868    fn init() -> String {
869        let _ = env_logger::try_init();
870        exe_path().unwrap()
871    }
872}
corepc_node/lib.rs

corepc_node/
lib.rs
