Struct UtxoParser 

pub struct UtxoParser { /* private fields */ }

Multithreaded parser that returns a ParserIterator of UtxoBlock

• Tracks the TxOut of every TxIn
• Tracks the OutputStatus for every TxOut

Examples

Computing the largest mining fee requires knowing the input amounts of every transaction. Call UtxoParser::parse to get a UtxoBlock that tracks input amounts.

use std::cmp::max;
use bitcoin::Amount;
use bitcoin_block_parser::utxos::*;

let parser = UtxoParser::new("/home/user/.bitcoin/blocks/", "filter.bin");
let fees = parser.parse(|block| {
    let mut max_mining_fee = Amount::ZERO;
    for tx in block.txdata.into_iter() {
        // For every transaction sum up the input and output amounts
        let inputs: Amount = tx.input().map(|(_, out)| out.value).sum();
        let outputs: Amount = tx.output().map(|(out, _)| out.value).sum();
        if !tx.transaction.is_coinbase() {
            // Subtract outputs amount from inputs amount to get the fee
            max_mining_fee = max(inputs - outputs, max_mining_fee);
        }
    }
    max_mining_fee
}).unwrap();
println!("Maximum mining fee: {}", fees.max().unwrap());

Computing the largest UTXO requires knowing the OutputStatus to determine whether a TxOut was spent or unspent.

use std::cmp::max;
use bitcoin::Amount;
use bitcoin_block_parser::utxos::*;

let parser = UtxoParser::new("/home/user/.bitcoin/blocks/", "filter.bin");
let amounts = parser.parse(|block| {
    let mut max_unspent_tx = Amount::ZERO;
    for tx in block.txdata.into_iter() {
        for (output, status) in tx.output() {
            if status == &OutputStatus::Unspent {
                max_unspent_tx = max(output.value, max_unspent_tx);
            }
        }
    }
    max_unspent_tx
}).unwrap();
println!("Maximum unspent output: {}", amounts.max().unwrap());

Implementations

impl UtxoParser

pub fn new(blocks_dir: &str, filter_file: &str) -> Self

Creates a new parser.

• blocks_dir - directory where the *.blk files are located.
• filter_file - file that will store the UTXO filter.

Returns an Err if unable to parse the blk files. You can specify the blocks directory when running bitcoind.

pub fn estimated_utxos(self, estimated_utxos: usize) -> Self

Set the estimated amount of UTXOs in the range of blocks you are parsing.

Used to lower the memory usage of shared state objects.

pub fn end_height(self, end_height: usize) -> Self

Sets the inclusive end of block heights to parse. Parsing always starts at the genesis block in order to track the transaction graph properly.

• end_height - the height to end at, usize::MAX will stop at the last block available.

pub fn with_opts(self, options: ParserOptions) -> Self

Creates a parser with custom ParserOptions.

pub fn parse<T: Send + 'static>( self, extract: impl Fn(UtxoBlock) -> T + Clone + Send + 'static, ) -> Result<ParserIterator<T>>

Parse all UtxoBlock into type T and return a ParserIterator<T>. Results will be in random order due to multithreading.

• extract - a closure that runs on multiple threads. For best performance perform as much computation and data reduction here as possible.

pub fn create_filter(&self) -> Result<Self>

Force the creation of a new filter_file.

Trait Implementations

impl Clone for UtxoParser

fn clone(&self) -> UtxoParser

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UtxoParser

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.