brk_indexer 0.11.1

A Bitcoin indexer built on top of brk_reader
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
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

use bitcoin::{Script, WitnessVersion};
use brk_types::OutputType;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Kind {
    None,
    P2WPKH,
    P2WSH,
    Witness,
    Other,
}

#[derive(Clone, Copy)]
pub(super) struct Facts {
    kind: Kind,
    sigops: usize,
}

impl Facts {
    pub(super) fn analyze(last_push: Option<&[u8]>, output_type: OutputType) -> Self {
        if output_type != OutputType::P2SH {
            return Self::NONE;
        }

        let Some(bytes) = last_push else {
            return Self::NONE;
        };
        let script = Script::from_bytes(bytes);
        let kind = match script.witness_version() {
            Some(WitnessVersion::V0) if script.len() == 22 => Kind::P2WPKH,
            Some(WitnessVersion::V0) if script.len() == 34 => Kind::P2WSH,
            Some(_) => Kind::Witness,
            None => Kind::Other,
        };

        Self {
            kind,
            sigops: script.count_sigops(),
        }
    }

    pub(super) fn effective_output_type(
        self,
        output_type: OutputType,
        witness_items: usize,
    ) -> OutputType {
        match self.kind {
            Kind::P2WPKH if witness_items == 2 => OutputType::P2WPKH,
            _ => output_type,
        }
    }

    pub(super) fn is_present(self) -> bool {
        self.kind != Kind::None
    }

    pub(super) fn is_p2wpkh(self) -> bool {
        self.kind == Kind::P2WPKH
    }

    pub(super) fn is_p2wsh(self) -> bool {
        self.kind == Kind::P2WSH
    }

    pub(super) fn is_witness_program(self) -> bool {
        matches!(self.kind, Kind::P2WPKH | Kind::P2WSH | Kind::Witness)
    }

    pub(super) fn sigops(self) -> Option<usize> {
        self.is_present().then_some(self.sigops)
    }

    const NONE: Self = Self {
        kind: Kind::None,
        sigops: 0,
    };
}

#[cfg(test)]
mod tests {
    use bitcoin::ScriptBuf;
    use brk_types::OutputType;

    use super::{Facts, Kind};

    fn classify(hex: &str) -> Facts {
        let script = ScriptBuf::from_hex(hex).unwrap();
        Facts::analyze(Some(script.as_bytes()), OutputType::P2SH)
    }

    #[test]
    fn classifies_redeem_scripts_once() {
        assert_eq!(
            classify("00140000000000000000000000000000000000000000").kind,
            Kind::P2WPKH
        );
        assert_eq!(
            classify("00200000000000000000000000000000000000000000000000000000000000000000").kind,
            Kind::P2WSH
        );
        assert_eq!(
            classify("51200000000000000000000000000000000000000000000000000000000000000000").kind,
            Kind::Witness
        );
        assert_eq!(classify("ac").kind, Kind::Other);
        assert_eq!(classify("ac").sigops(), Some(1));
        assert_eq!(Facts::analyze(None, OutputType::P2SH).kind, Kind::None);
        assert_eq!(
            Facts::analyze(Some(&[0xac]), OutputType::P2PKH).kind,
            Kind::None
        );
    }
}