rns-embedded-mininode 0.7.0

Minimal embedded Reticulum node helpers for constrained LXMF deployments.
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

use alloc::vec::Vec;
use rns_core::identity::{Identity, PRIVATE_KEY_LENGTH};

use crate::{
    error::MiniNodeError,
    telemetry::{PositionFix, TelemetryPoint},
};

#[derive(Clone)]
pub struct NeighborSnapshot {
    pub destination_hash: [u8; 16],
    pub identity: Identity,
    pub last_seen_ms: u64,
    pub app_data: Vec<u8>,
}

#[derive(Clone, Default)]
pub struct NodeSnapshot {
    pub last_announce_ms: Option<u64>,
    pub neighbors: Vec<NeighborSnapshot>,
    pub recent_message_ids: Vec<[u8; 32]>,
    pub telemetry: Vec<TelemetryPoint>,
    pub latest_position: Option<PositionFix>,
}

pub trait MiniNodeStore {
    fn load_identity(&self) -> Result<Option<[u8; PRIVATE_KEY_LENGTH]>, MiniNodeError>;
    fn save_identity(
        &mut self,
        identity_bytes: &[u8; PRIVATE_KEY_LENGTH],
    ) -> Result<(), MiniNodeError>;
    fn load_snapshot(&self) -> Result<Option<NodeSnapshot>, MiniNodeError>;
    fn save_snapshot(&mut self, snapshot: &NodeSnapshot) -> Result<(), MiniNodeError>;
}

#[derive(Clone, Default)]
pub struct MemoryStore {
    identity: Option<[u8; PRIVATE_KEY_LENGTH]>,
    snapshot: Option<NodeSnapshot>,
}

impl MemoryStore {
    pub fn new() -> Self {
        Self::default()
    }
}

impl MiniNodeStore for MemoryStore {
    fn load_identity(&self) -> Result<Option<[u8; PRIVATE_KEY_LENGTH]>, MiniNodeError> {
        Ok(self.identity)
    }

    fn save_identity(
        &mut self,
        identity_bytes: &[u8; PRIVATE_KEY_LENGTH],
    ) -> Result<(), MiniNodeError> {
        self.identity = Some(*identity_bytes);
        Ok(())
    }

    fn load_snapshot(&self) -> Result<Option<NodeSnapshot>, MiniNodeError> {
        Ok(self.snapshot.clone())
    }

    fn save_snapshot(&mut self, snapshot: &NodeSnapshot) -> Result<(), MiniNodeError> {
        self.snapshot = Some(snapshot.clone());
        Ok(())
    }
}