pushtx 0.4.0

Bitcoin Transaction Broadcast Library
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

use bitcoin::p2p::message::NetworkMessage;
use bitcoin::p2p::message_network::VersionMessage;

/// Types of updates that an in-progress handshake wants to know about.
#[derive(Debug)]
pub enum Update {
    /// The peer sent a `Version` message.
    Version(VersionMessage),
    /// The peer sent a `Verack` message.
    Verack,
    /// The peer sent a `SendAddrV2` message (BIP-155).
    SendAddrV2,
    /// The peer sent a `WtxidRelay` message (BIP-0339).
    WtxidRelay,
    /// The peer sent another message.
    Other,
}

impl From<&NetworkMessage> for Update {
    fn from(value: &NetworkMessage) -> Self {
        match value {
            NetworkMessage::Version(v) => Self::Version(v.clone()),
            NetworkMessage::Verack => Self::Verack,
            NetworkMessage::SendAddrV2 => Self::SendAddrV2,
            NetworkMessage::WtxidRelay => Self::WtxidRelay,
            _ => Self::Other,
        }
    }
}

#[derive(Debug)]
pub enum Event<'a> {
    Wait,
    /// Send a `Verack` message to the peer.
    SendVerack,
    /// The peer violated the handshake protocol.
    Violation,
    /// The handshake is done.
    Done {
        /// The peer's advertised version.
        version: &'a VersionMessage,
        /// Whether the peer prefers AddrV2 messages.
        wants_addr_v2: bool,
        /// Wtxid relay
        wtxid_relay: bool,
    },
}

/// Contains the state of a handshake with a peer.
#[derive(Debug, Default)]
pub struct Handshake {
    /// The version message maybe received from the peer.
    their_version: Option<VersionMessage>,
    ///  Whether their verack has been received.
    their_verack: bool,
    /// Whether the peer prefers AddrV2 messages.
    wants_addr_v2: bool,
    /// Wtxid relay
    wtxid_relay: bool,
}

impl Handshake {
    /// Updates the handshake.
    pub fn update(&mut self, update: Update) -> Event {
        match (self, update) {
            (
                Self {
                    their_version: their_version @ None,
                    their_verack: false,
                    ..
                },
                Update::Version(v),
            ) => {
                *their_version = Some(v);
                Event::SendVerack
            }

            (
                Self {
                    their_version: Some(_),
                    their_verack: false,
                    wants_addr_v2: wants_addr_v2 @ false,
                    ..
                },
                Update::SendAddrV2,
            ) => {
                *wants_addr_v2 = true;
                Event::Wait
            }

            (
                Self {
                    their_version: Some(_),
                    their_verack: false,
                    wtxid_relay: wtxid_relay @ false,
                    ..
                },
                Update::WtxidRelay,
            ) => {
                *wtxid_relay = true;
                Event::Wait
            }

            (
                Self {
                    their_version: Some(v),
                    their_verack: their_verack @ false,
                    wants_addr_v2,
                    wtxid_relay,
                },
                Update::Verack,
            ) => {
                *their_verack = true;
                Event::Done {
                    version: v,
                    wants_addr_v2: *wants_addr_v2,
                    wtxid_relay: *wtxid_relay,
                }
            }

            _ => Event::Violation,
        }
    }
}