blvm-node 0.1.73

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

//! Tests for message bridge

use blvm_node::network::message_bridge::MessageBridge;
use blvm_node::network::transport::TransportType;
use blvm_protocol::network::{
    NetworkAddress, NetworkMessage, NetworkResponse, PingMessage, VersionMessage,
};

fn create_test_version_message() -> NetworkMessage {
    NetworkMessage::Version(VersionMessage {
        version: 70015,
        services: 1,
        timestamp: 1234567890,
        addr_recv: NetworkAddress {
            time: 0,
            services: 1,
            ip: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 1],
            port: 8333,
        },
        addr_from: NetworkAddress {
            time: 0,
            services: 1,
            ip: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 1],
            port: 8334,
        },
        nonce: 12345,
        user_agent: "test".to_string(),
        start_height: 0,
        relay: true,
    })
}

#[test]
fn test_message_bridge_to_transport_tcp() {
    let msg = create_test_version_message();

    let result = MessageBridge::to_transport_message(&msg, TransportType::Tcp);
    assert!(result.is_ok());

    let wire = result.unwrap();
    assert!(!wire.is_empty());
}

#[test]
fn test_message_bridge_from_transport_tcp() {
    let msg = create_test_version_message();

    // Serialize first
    let wire = MessageBridge::to_transport_message(&msg, TransportType::Tcp).unwrap();
    assert!(!wire.is_empty());

    let decoded = MessageBridge::from_transport_message(&wire, TransportType::Tcp)
        .expect("version round trip");
    assert_eq!(decoded, msg);
}

#[test]
fn test_message_bridge_roundtrip() {
    let original = create_test_version_message();

    // Convert to transport
    let wire = MessageBridge::to_transport_message(&original, TransportType::Tcp).unwrap();
    assert!(!wire.is_empty());

    let converted = MessageBridge::from_transport_message(&wire, TransportType::Tcp)
        .expect("version round trip");
    assert_eq!(converted, original);
}

#[test]
fn test_message_bridge_extract_send_messages_ok() {
    let response = NetworkResponse::Ok;

    let result = MessageBridge::extract_send_messages(&response, TransportType::Tcp);
    assert!(result.is_ok());

    let messages = result.unwrap();
    assert_eq!(messages.len(), 0);
}

#[test]
fn test_message_bridge_extract_send_messages_send_message() {
    let msg = create_test_version_message();
    let response = NetworkResponse::SendMessage(Box::new(msg));

    let result = MessageBridge::extract_send_messages(&response, TransportType::Tcp);
    assert!(result.is_ok());

    let messages = result.unwrap();
    assert_eq!(messages.len(), 1);
    assert!(!messages[0].is_empty());
}

#[test]
fn test_message_bridge_extract_send_messages_send_messages() {
    let msg1 = create_test_version_message();
    let msg2 = NetworkMessage::Ping(PingMessage { nonce: 12345 });
    let response = NetworkResponse::SendMessages(vec![msg1, msg2]);

    let result = MessageBridge::extract_send_messages(&response, TransportType::Tcp);
    assert!(result.is_ok());

    let messages = result.unwrap();
    assert_eq!(messages.len(), 2);
    assert!(!messages[0].is_empty());
    assert!(!messages[1].is_empty());
}

#[test]
fn test_message_bridge_extract_send_messages_reject() {
    let response = NetworkResponse::Reject("test rejection".to_string());

    let result = MessageBridge::extract_send_messages(&response, TransportType::Tcp);
    assert!(result.is_ok());

    let messages = result.unwrap();
    assert_eq!(messages.len(), 0);
}