brk_computer 0.11.2

A Bitcoin dataset computer built on top of brk_indexer
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use brk_types::{OutputType, Sats, TypeIndex};
use rustc_hash::FxHashSet;

type Address = (OutputType, TypeIndex);

#[derive(Default)]
pub(super) struct Candidate {
    values: FxHashSet<Sats>,
    input_addresses: FxHashSet<Address>,
    output_addresses: FxHashSet<Address>,
    zero_values: usize,
    address_reuse: bool,
}

impl Candidate {
    pub(super) fn clear(&mut self) {
        self.values.clear();
        self.input_addresses.clear();
        self.output_addresses.clear();
        self.zero_values = 0;
        self.address_reuse = false;
    }

    pub(super) fn add_input(
        &mut self,
        value: Sats,
        output_type: OutputType,
        type_index: TypeIndex,
    ) {
        self.add_value(value);
        if has_script_address(output_type) {
            self.address_reuse |= !self.input_addresses.insert((output_type, type_index));
        }
    }

    pub(super) fn add_output(
        &mut self,
        value: Sats,
        output_type: OutputType,
        type_index: TypeIndex,
    ) {
        self.add_value(value);
        if has_script_address(output_type) {
            let address = (output_type, type_index);
            self.address_reuse |=
                self.input_addresses.contains(&address) || !self.output_addresses.insert(address);
        }
    }

    pub(super) fn is_match(&self, input_count: usize, output_count: usize) -> bool {
        !self.address_reuse
            && self.values.len() + self.zero_values <= (input_count + output_count) / 2
    }

    fn add_value(&mut self, value: Sats) {
        if value.is_zero() {
            self.zero_values += 1;
        } else {
            self.values.insert(value);
        }
    }
}

fn has_script_address(output_type: OutputType) -> bool {
    matches!(
        output_type,
        OutputType::P2PK65
            | OutputType::P2PK33
            | OutputType::P2PKH
            | OutputType::P2SH
            | OutputType::P2WPKH
            | OutputType::P2WSH
            | OutputType::P2TR
            | OutputType::P2A
    )
}

#[cfg(test)]
mod tests {
    use brk_types::{OutputType, Sats, TypeIndex};

    use super::Candidate;

    #[test]
    fn repeated_values_match_without_address_reuse() {
        let mut candidate = Candidate::default();
        for index in 0usize..5 {
            candidate.add_input(
                Sats::new(10_000),
                OutputType::P2WPKH,
                TypeIndex::from(index),
            );
            candidate.add_output(
                Sats::new(9_000),
                OutputType::P2WPKH,
                TypeIndex::from(index + 10),
            );
        }
        assert!(candidate.is_match(5, 5));
    }

    #[test]
    fn reused_output_address_does_not_match() {
        let mut candidate = Candidate::default();
        for _ in 0..5 {
            candidate.add_output(
                Sats::new(9_000),
                OutputType::P2WPKH,
                TypeIndex::from(1usize),
            );
        }
        assert!(!candidate.is_match(5, 5));
    }

    #[test]
    fn reused_input_address_does_not_match() {
        let mut candidate = Candidate::default();
        for _ in 0..5 {
            candidate.add_input(
                Sats::new(10_000),
                OutputType::P2PK33,
                TypeIndex::from(1usize),
            );
        }
        assert!(!candidate.is_match(5, 5));
    }
}