blvm-node 0.1.53

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

//! heed3 default-backend smoke: fresh datadir, chain + UTXO writes, LMDB persistence on reopen.
//!
//! Requires liblmdb. Build with `--features heed3`.

#[cfg(feature = "heed3")]
mod common;

#[cfg(feature = "heed3")]
mod heed3_ibd_smoke {
    use super::common::setup_mining_chain;
    use blvm_node::storage::Storage;
    use blvm_node::storage::database::{DatabaseBackend, default_backend};
    use blvm_node::{OutPoint, UTXO};
    use std::sync::Arc;
    use tempfile::TempDir;

    const BLOCKS: u64 = 50;

    fn heed3_env_exists(datadir: &std::path::Path) -> bool {
        let heed3_dir = datadir.join("heed3");
        if !heed3_dir.is_dir() {
            return false;
        }
        // LMDB data file name varies by heed3/lmdb version; any non-empty env dir is enough.
        std::fs::read_dir(&heed3_dir)
            .map(|mut d| d.next().is_some())
            .unwrap_or(false)
    }

    #[test]
    fn heed3_auto_backend_fresh_datadir_connect_and_restart() {
        assert_eq!(
            default_backend(),
            DatabaseBackend::Heed3,
            "standard build must default to heed3"
        );

        let temp_dir = TempDir::new().unwrap();
        let datadir = temp_dir.path();

        let outpoint = OutPoint {
            hash: [0xab; 32],
            index: 7,
        };
        let utxo = UTXO {
            value: 50_000,
            script_pubkey: vec![0x51].into(),
            height: BLOCKS - 1,
            is_coinbase: false,
        };

        let expected_height = {
            let storage = Arc::new(Storage::new(datadir).expect("open heed3 via Storage::new"));
            assert_eq!(
                storage.utxo_value_codec(),
                blvm_node::storage::utxo_value_codec::ValueCodec::Rkyv
            );

            setup_mining_chain(&storage, BLOCKS).expect("seed chain");

            storage
                .utxos()
                .add_utxo(&outpoint, &utxo)
                .expect("persist UTXO on heed3");

            let height = storage.chain().get_height().expect("height").unwrap_or(0);
            assert!(
                height >= BLOCKS - 1,
                "expected chain height >= {} got {height}",
                BLOCKS - 1
            );

            storage
                .utxos()
                .get_utxo(&outpoint)
                .expect("read UTXO")
                .expect("UTXO must exist before drop");

            height
        };

        assert!(
            heed3_env_exists(datadir),
            "default backend must create heed3/ LMDB env under datadir"
        );

        // Restart: reopen via auto path (validates heed3 persistence after process-level drop).
        let storage2 = Storage::new(datadir).expect("reopen after drop");
        let height2 = storage2.chain().get_height().expect("height").unwrap_or(0);
        assert_eq!(
            height2, expected_height,
            "chain height must persist across reopen"
        );

        let got = storage2
            .utxos()
            .get_utxo(&outpoint)
            .expect("read UTXO after reopen")
            .expect("UTXO must persist across reopen");
        assert_eq!(got, utxo);

        // LMDB allows only one env handle per process; drop before a second open.
        drop(storage2);
        let storage3 =
            Storage::with_backend(datadir, DatabaseBackend::Heed3).expect("explicit heed3 reopen");
        assert_eq!(
            storage3.chain().get_height().expect("height").unwrap_or(0),
            expected_height
        );
        assert_eq!(
            storage3
                .utxos()
                .get_utxo(&outpoint)
                .expect("read")
                .expect("UTXO"),
            utxo
        );
    }
}