blvm-consensus 0.1.12

Bitcoin Commons BLVM: Direct mathematical implementation of Bitcoin consensus rules from the Orange Paper
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
128
129
130
131
132
133
134
135

use blvm_consensus::{block, Transaction, TransactionInput, TransactionOutput, OutPoint, BlockHeader, Block, UtxoSet};

fn create_invalid_block() -> Block {
    Block {
        header: BlockHeader {
            version: 1,
            prev_block_hash: [0; 32],
            merkle_root: [0; 32],
            timestamp: 0, // Invalid timestamp (before genesis)
            bits: 0x0300ffff,
            nonce: 0,
        },
        transactions: vec![], // Empty block (should be invalid)
    }
}

fn create_valid_coinbase_block() -> Block {
    let coinbase_tx = Transaction {
        version: 1,
        inputs: vec![TransactionInput {
            prevout: OutPoint { hash: [0; 32].into(), index: 0xffffffff },
            script_sig: vec![0x51],
            sequence: 0xffffffff,
        }].into(),
        outputs: vec![TransactionOutput { value: 50_000_000_000, script_pubkey: vec![0x51].into() }].into(),
        lock_time: 0,
    };
    
    Block {
        header: BlockHeader {
            version: 1,
            prev_block_hash: [0; 32],
            merkle_root: [0; 32],
            timestamp: 1231006505,
            bits: 0x0300ffff,
            nonce: 0,
        },
            transactions: vec![coinbase_tx].into(),
    }
}

#[test]
fn test_connect_block_empty_transactions() {
    let block = create_invalid_block();
    let utxo = UtxoSet::default();
    let height = 1;
    
    // Empty block should fail validation
    let witnesses: Vec<segwit::Witness> = block.transactions.iter().map(|_| Vec::new()).collect();
    let ctx = block::BlockValidationContext::for_network(crate::types::Network::Mainnet);
    let result = block::connect_block(&block, &witnesses, utxo, height, &ctx);
    // May succeed or fail depending on implementation, just exercise the path
    let _ = result;
}

#[test]
fn test_connect_block_invalid_timestamp() {
    let block = create_invalid_block();
    let utxo = UtxoSet::default();
    let height = 1;
    
    // Block with invalid timestamp should be handled
    let witnesses: Vec<segwit::Witness> = block.transactions.iter().map(|_| Vec::new()).collect();
    let ctx = block::BlockValidationContext::for_network(crate::types::Network::Mainnet);
    let result = block::connect_block(&block, &witnesses, utxo, height, &ctx);
    let _ = result;
}

#[test]
fn test_connect_block_valid_coinbase() {
    let block = create_valid_coinbase_block();
    let utxo = UtxoSet::default();
    let height = 1;
    
    // Valid coinbase block should be processed
    let witnesses: Vec<segwit::Witness> = block.transactions.iter().map(|_| Vec::new()).collect();
    let ctx = block::BlockValidationContext::for_network(crate::types::Network::Mainnet);
    let result = block::connect_block(&block, &witnesses, utxo, height, &ctx);
    let _ = result;
}

#[test]
fn test_apply_transaction_coinbase() {
    let coinbase_tx = Transaction {
        version: 1,
        inputs: vec![TransactionInput {
            prevout: OutPoint { hash: [0; 32].into(), index: 0xffffffff },
            script_sig: vec![0x51],
            sequence: 0xffffffff,
        }].into(),
        outputs: vec![TransactionOutput { value: 50_000_000_000, script_pubkey: vec![0x51].into() }].into(),
        lock_time: 0,
    };
    
    let mut utxo = UtxoSet::default();
    let height = 1;
    
    // Apply coinbase transaction
    let result = block::apply_transaction(&coinbase_tx, &mut utxo, height);
    let _ = result;
}