bvc 0.1.1

This is a simple binary program which calculates the value of a given block on the Bitcoin network. You can specify the block by its height, hash, or get the best block.
Documentation 
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

use bitcoin::{Amount, Block, BlockHash};
use bitcoincore_rpc::{Auth, Client, RpcApi};
use std::{path::PathBuf, str::FromStr};

pub mod config;

pub struct BlockValueCalculator {
    rpc: Client,
}

impl BlockValueCalculator {
    pub fn new(cfg: config::Config) -> Self {
        let rpc_auth: Auth;

        if cfg.auth_default {
            rpc_auth = Auth::CookieFile(PathBuf::from(cfg.path_to_auth_cookie));
        } else {
            rpc_auth = Auth::UserPass(cfg.rpc_username.unwrap(), cfg.rpc_password.unwrap());
        }

        let rpc = Client::new(cfg.rpc_url.as_str(), rpc_auth).expect("Failed to create RPC client");
        BlockValueCalculator { rpc }
    }

    pub fn calculate_total_value(&self, block: &Block) -> (usize, Amount, BlockHash) {
        let mut total_value: Amount = Amount::from_btc(0.0).expect("Wasn't able to parse from_btc");
        let tx_count = block.txdata.len();
        let mut count = 0;
        for tx in block.txdata.iter() {
            let txid = tx.compute_txid();
            count += 1;
            println!("Processing transaction: {}", &txid);
            let transaction = self
                .rpc
                .get_raw_transaction(&txid, None)
                .expect("Wasn't able to get transaction ");
            for txout in transaction.output.iter() {
                total_value += txout.value;
            }

            let st = "=".repeat(txid.as_raw_hash().to_string().len());
            println!("{}/{count}", block.txdata.len());
            println!("{}{}", "=".repeat(23), st);
        }
        (tx_count, total_value, block.block_hash())
    }

    pub fn get_block_from_height(&self, block_height: u64) -> Block {
        let block_hash = self
            .rpc
            .get_block_hash(block_height)
            .expect("Wasn't able to find the best hash");

        self.rpc
            .get_block(&block_hash)
            .expect("Wasn't able to receive block")
    }

    pub fn get_block_from_hash(&self, hash: String) -> Block {
        let block_hash = BlockHash::from_str(hash.as_str()).unwrap();
        self.rpc.get_block(&block_hash).unwrap()
    }

    pub fn get_best_block(&self) -> Block {
        let block_hash = self.rpc.get_best_block_hash().unwrap();
        self.rpc.get_block(&block_hash).unwrap()
    }
}