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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use bitcoin::secp256k1::{All, PublicKey, Secp256k1};
use bitcoin::Network;
use lightning_signer::bitcoin;
use lightning_signer::node::SignedHeartbeat;
use log::*;
use std::sync::Mutex;
use std::time::SystemTime;

struct State {
    // seconds since the epoch of the last notification
    last_timestamp: u64,
    // the last heartbeat we received
    last_heartbeat: Option<SignedHeartbeat>,
}

pub struct HeartbeatMonitor {
    pubkey: PublicKey,
    secp: Secp256k1<All>,
    log_prefix: String,
    // number of seconds between notifications
    notify_interval: u64,
    // number of seconds until a heartbeat is considered stale
    stale_interval: u64,
    state: Mutex<State>,
}

#[cfg_attr(test, derive(PartialEq, Debug))]
enum HeartbeatStatus {
    // heartbeat is fresh
    Fresh,
    // heartbeat is stale
    Stale,
    // heartbeat is missing
    Missing,
    // heartbeat timestamp is in the future
    Future,
}

impl HeartbeatMonitor {
    pub fn new(network: Network, pubkey: PublicKey, log_prefix: String) -> Self {
        let (notify_interval, stale_interval) = match network {
            Network::Bitcoin => (60, 3600),
            Network::Testnet => (60, 3600),
            Network::Regtest => (5, 5),
            Network::Signet => (5, 5),
        };
        Self {
            pubkey,
            secp: Secp256k1::new(),
            log_prefix,
            notify_interval,
            stale_interval,
            state: Mutex::new(State { last_timestamp: 0, last_heartbeat: None }),
        }
    }

    pub fn on_heartbeat(&self, heartbeat: SignedHeartbeat) {
        let ok = heartbeat.verify(&self.pubkey, &self.secp);
        if ok {
            let mut state = self.state.lock().unwrap();
            info!("{} heartbeat: height {:?}", self.log_prefix, heartbeat.heartbeat.chain_height);
            state.last_heartbeat = Some(heartbeat);
            state.last_timestamp = Self::now();
        } else {
            error!(
                "{} heartbeat signature verify failed: {:?} pubkey {}",
                self.log_prefix, heartbeat, self.pubkey
            );
        }
    }

    pub fn on_tick(&self) {
        let now = Self::now();
        let mut state = self.state.lock().unwrap();
        match status(state.last_heartbeat.as_ref(), now, self.stale_interval) {
            HeartbeatStatus::Fresh => {}
            HeartbeatStatus::Stale =>
                if now > state.last_timestamp + self.notify_interval {
                    error!(
                        "{} heartbeat stale: {:?}",
                        self.log_prefix,
                        state.last_heartbeat.as_ref()
                    );
                    state.last_timestamp = now;
                },
            HeartbeatStatus::Missing =>
                if now > state.last_timestamp + self.notify_interval {
                    error!("{} no heartbeat", self.log_prefix);
                    state.last_timestamp = now;
                },
            HeartbeatStatus::Future => {
                error!(
                    "{} heartbeat timestamp in the future: {:?} now {}",
                    self.log_prefix,
                    state.last_heartbeat.as_ref(),
                    now
                );
            }
        }
    }

    fn now() -> u64 {
        SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs()
    }
}

fn status(
    heartbeat_opt: Option<&SignedHeartbeat>,
    now: u64,
    stale_interval: u64,
) -> HeartbeatStatus {
    if let Some(heartbeat) = heartbeat_opt.as_ref() {
        let heartbeat_ts = heartbeat.heartbeat.current_timestamp as u64;
        if now < heartbeat_ts {
            HeartbeatStatus::Future
        } else if now > heartbeat_ts + stale_interval {
            HeartbeatStatus::Stale
        } else {
            HeartbeatStatus::Fresh
        }
    } else {
        HeartbeatStatus::Missing
    }
}

#[cfg(test)]
mod tests {
    use bitcoin::hashes::Hash;
    use bitcoin::BlockHash;
    use lightning_signer::bitcoin;
    use lightning_signer::node::Heartbeat;

    #[test]
    fn status_test() {
        let heartbeat = super::SignedHeartbeat {
            heartbeat: Heartbeat {
                chain_tip: BlockHash::all_zeros(),
                chain_height: 0,
                chain_timestamp: 0,
                current_timestamp: 1000,
            },
            signature: [0; 64].to_vec(),
        };
        assert_eq!(super::status(Some(&heartbeat), 999, 100), super::HeartbeatStatus::Future);
        assert_eq!(super::status(None, 1000, 100), super::HeartbeatStatus::Missing);
        assert_eq!(super::status(Some(&heartbeat), 1000, 100), super::HeartbeatStatus::Fresh);
        assert_eq!(super::status(Some(&heartbeat), 1100, 100), super::HeartbeatStatus::Fresh);
        assert_eq!(super::status(Some(&heartbeat), 1101, 100), super::HeartbeatStatus::Stale);
    }
}