blk 0.3.5

A CLI to inspect Bitcoin Core blocks
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::{collections::HashSet, path::PathBuf};

use brk_error::{Error, Result};
use brk_rpc::{Auth, Client};

use crate::path::Path;

pub struct Args {
    pub selector: String,
    pub paths: Vec<Path>,
    pub pretty: bool,
    pub compact: bool,
    bitcoindir: Option<PathBuf>,
    blocksdir: Option<PathBuf>,
    rpcconnect: Option<String>,
    rpcport: Option<u16>,
    rpccookiefile: Option<PathBuf>,
    rpcuser: Option<String>,
    rpcpassword: Option<String>,
}

impl Args {
    pub fn parse(raw: Vec<String>) -> Result<Self> {
        let mut pretty = false;
        let mut compact = false;
        let mut bitcoindir = None;
        let mut blocksdir = None;
        let mut rpcconnect = None;
        let mut rpcport = None;
        let mut rpccookiefile = None;
        let mut rpcuser = None;
        let mut rpcpassword = None;
        let mut positional: Vec<String> = Vec::new();
        let mut iter = raw.into_iter();
        while let Some(a) = iter.next() {
            if a == "-p" || a == "--pretty" {
                pretty = true;
                continue;
            }
            if a == "-c" || a == "--compact" {
                compact = true;
                continue;
            }
            if let Some(rest) = a.strip_prefix("--") {
                let (key, value) = match rest.split_once('=') {
                    Some((k, v)) => (k.to_string(), v.to_string()),
                    None => (
                        rest.to_string(),
                        iter.next()
                            .ok_or_else(|| Error::Parse(format!("--{rest} requires a value")))?,
                    ),
                };
                match key.as_str() {
                    "bitcoindir" => bitcoindir = Some(PathBuf::from(value)),
                    "blocksdir" => blocksdir = Some(PathBuf::from(value)),
                    "rpcconnect" => rpcconnect = Some(value),
                    "rpcport" => {
                        rpcport = Some(value.parse().map_err(|_| {
                            Error::Parse(format!("--rpcport: '{value}' is not a valid port"))
                        })?);
                    }
                    "rpccookiefile" => rpccookiefile = Some(PathBuf::from(value)),
                    "rpcuser" => rpcuser = Some(value),
                    "rpcpassword" => rpcpassword = Some(value),
                    other => return Err(Error::Parse(format!("unknown flag --{other}"))),
                }
                continue;
            }
            if a.starts_with('-') {
                return Err(Error::Parse(format!("unknown flag {a}")));
            }
            positional.push(a);
        }

        let mut iter = positional.into_iter();
        let selector = iter
            .next()
            .ok_or_else(|| Error::Parse("missing selector".into()))?;
        let paths: Vec<Path> = iter.map(|f| Path::parse(&f)).collect::<Result<_>>()?;
        let mut seen = HashSet::with_capacity(paths.len());
        for p in &paths {
            if !seen.insert(p.raw.as_str()) {
                return Err(Error::Parse(format!("duplicate field '{}'", p.raw)));
            }
        }
        Ok(Self {
            selector,
            paths,
            pretty,
            compact,
            bitcoindir,
            blocksdir,
            rpcconnect,
            rpcport,
            rpccookiefile,
            rpcuser,
            rpcpassword,
        })
    }

    pub fn bitcoin_dir(&self) -> PathBuf {
        self.bitcoindir
            .clone()
            .unwrap_or_else(Client::default_bitcoin_path)
    }

    pub fn blocks_dir(&self) -> PathBuf {
        self.blocksdir
            .clone()
            .unwrap_or_else(|| self.bitcoin_dir().join("blocks"))
    }

    pub fn rpc(&self) -> Result<Client> {
        let host = self.rpcconnect.as_deref().unwrap_or("localhost");
        let port = self.rpcport.unwrap_or(8332);
        let url = format!("http://{host}:{port}");
        let cookie = self
            .rpccookiefile
            .clone()
            .unwrap_or_else(|| self.bitcoin_dir().join(".cookie"));
        let auth = if cookie.is_file() {
            Auth::CookieFile(cookie)
        } else if let (Some(u), Some(p)) = (self.rpcuser.as_deref(), self.rpcpassword.as_deref()) {
            Auth::UserPass(u.to_string(), p.to_string())
        } else {
            return Err(Error::Parse(
                "no RPC auth: cookie file missing and --rpcuser/--rpcpassword not set".into(),
            ));
        };
        Client::new(&url, auth)
    }
}