blvm-node 0.1.47

Bitcoin Commons BLVM: Minimal Bitcoin node implementation using blvm-protocol and blvm-consensus
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

//! Fork-choice helpers: compare cumulative chainwork at tips.

use crate::storage::Storage;
use anyhow::Result;
use blvm_protocol::Hash;

use blvm_consensus::pow::U256;

/// Return cumulative chainwork for a block hash (zero when unknown).
pub fn chainwork_at(storage: &Storage, hash: &Hash) -> Result<U256> {
    Ok(storage
        .chain()
        .get_chainwork(hash)?
        .unwrap_or_else(U256::zero))
}

fn sequence_id_at(storage: &Storage, hash: &Hash) -> u64 {
    storage
        .chain()
        .block_index()
        .get(hash)
        .ok()
        .flatten()
        .map(|e| e.sequence_id)
        .unwrap_or(u64::MAX)
}

/// True when `candidate_tip` should replace the active tip (more work, or equal work with lower sequence).
pub fn should_activate_over_active_tip(storage: &Storage, candidate_tip: &Hash) -> Result<bool> {
    let (active_tip, _) = storage.chain().get_tip_hash_and_height()?;
    if *candidate_tip == active_tip {
        return Ok(false);
    }
    let active_work = chainwork_at(storage, &active_tip)?;
    let candidate_work = chainwork_at(storage, candidate_tip)?;
    match candidate_work.cmp(&active_work) {
        std::cmp::Ordering::Greater => Ok(true),
        std::cmp::Ordering::Less => Ok(false),
        std::cmp::Ordering::Equal => {
            Ok(sequence_id_at(storage, candidate_tip) < sequence_id_at(storage, &active_tip))
        }
    }
}

/// True when `candidate_tip` has strictly more cumulative chainwork than the active tip.
pub fn heavier_than_active_tip(storage: &Storage, candidate_tip: &Hash) -> Result<bool> {
    let (active_tip, _) = storage.chain().get_tip_hash_and_height()?;
    if *candidate_tip == active_tip {
        return Ok(false);
    }
    let active_work = chainwork_at(storage, &active_tip)?;
    let candidate_work = chainwork_at(storage, candidate_tip)?;
    Ok(candidate_work > active_work)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::storage::Storage;
    use crate::storage::block_index::BlockIndexStatus;
    use blvm_protocol::BlockHeader;
    use tempfile::TempDir;

    use blvm_consensus::pow::U256;

    fn header() -> BlockHeader {
        BlockHeader {
            version: 1,
            prev_block_hash: [0u8; 32],
            merkle_root: [0u8; 32],
            timestamp: 0,
            bits: 0x207fffff,
            nonce: 0,
        }
    }

    fn storage_with_sibling_tips(first: Hash, second: Hash, tip: Hash, work: U256) -> Storage {
        let dir = TempDir::new().unwrap();
        let storage = Storage::new(dir.path()).unwrap();
        storage.chain().initialize(&header()).unwrap();

        let parent = [9u8; 32];
        storage
            .chain()
            .block_index()
            .insert(&parent, 0, &[0u8; 32], BlockIndexStatus::Valid)
            .unwrap();
        storage
            .chain()
            .block_index()
            .insert(&first, 1, &parent, BlockIndexStatus::Valid)
            .unwrap();
        storage
            .chain()
            .block_index()
            .insert(&second, 1, &parent, BlockIndexStatus::Valid)
            .unwrap();

        storage.chain().update_tip(&tip, &header(), 1).unwrap();
        storage.chain().store_chainwork(&first, work).unwrap();
        storage.chain().store_chainwork(&second, work).unwrap();
        storage
    }

    #[test]
    fn equal_work_prefers_lower_sequence() {
        let active = [1u8; 32];
        let candidate = [2u8; 32];
        let storage = storage_with_sibling_tips(active, candidate, active, U256::from_u128(100));
        assert!(!should_activate_over_active_tip(&storage, &candidate).unwrap());
    }

    #[test]
    fn equal_work_activates_earlier_sequence() {
        let active = [2u8; 32];
        let candidate = [1u8; 32];
        let storage = storage_with_sibling_tips(candidate, active, active, U256::from_u128(100));
        assert!(should_activate_over_active_tip(&storage, &candidate).unwrap());
    }

    #[test]
    fn heavier_work_always_activates() {
        let active = [1u8; 32];
        let candidate = [2u8; 32];
        let storage = storage_with_sibling_tips(active, candidate, active, U256::from_u128(100));
        storage
            .chain()
            .store_chainwork(&candidate, U256::from_u128(200))
            .unwrap();
        assert!(should_activate_over_active_tip(&storage, &candidate).unwrap());
    }
}