reticulum-pyrs 0.1.0

A rust wrapper for the python rns and lxmf libraries
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
136
137
138
139
140
141
142
143
144

use anyhow::{Result, anyhow};
use log::{error, info};
use pyo3::prelude::*;
use std::fmt::{Debug, Display, LowerHex};

#[derive(Clone, Copy, FromPyObject, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct LongHash([u8; 32]);

impl LongHash {
    /// Create a new LongHash from a slice. The slice must be of size 32, or it will error.
    pub fn new(b: &[u8]) -> Result<Self> {
        if b.len() == 32 {
            let mut buf = [0; 32];
            buf.copy_from_slice(b);
            Ok(Self(buf))
        } else {
            Err(anyhow!("Slice should be 32 bytes long!"))
        }
    }

    pub fn from_hex_str(hex: &str) -> Result<Self> {
        let hash = hex::decode(hex)?;
        if hash.len() == 32 {
            let mut bytes: [u8; 32] = [0; 32];
            bytes.copy_from_slice(&hash[..32]);
            Ok(Self(bytes))
        } else {
            Err(anyhow!(
                "hex string is wrong length -- it should be 32 bytes (64 ascii chars)"
            ))
        }
    }

    pub fn tiny_hash(&self) -> String {
        format!("{self:x}")[..7].to_string()
    }

    pub fn value(&self) -> [u8; 32] {
        self.0
    }
}

impl Display for LongHash {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:x}")
    }
}

impl Debug for LongHash {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:x}")
    }
}

impl LowerHex for LongHash {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let hex = hex::encode(self.0);
        write!(f, "{hex}")?;
        Ok(())
    }
}

#[derive(Clone, Copy, FromPyObject, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct ShortHash([u8; 16]);

impl ShortHash {
    /// Create a new LongHash from a slice. The slice should be of size 16, or it will error.
    pub fn new(b: &[u8]) -> Result<Self> {
        if b.len() == 16 {
            let mut buf = [0; 16];
            buf.copy_from_slice(b);
            Ok(Self(buf))
        } else {
            Err(anyhow!("Slice should be 16 bytes long!"))
        }
    }

    pub fn from_hex_str(hex: &str) -> Result<Self> {
        let hash = hex::decode(hex)?;
        if hash.len() == 16 {
            let mut bytes: [u8; 16] = [0; 16];
            bytes.copy_from_slice(&hash[..16]);
            Ok(Self(bytes))
        } else {
            Err(anyhow!(
                "hex string is wrong length -- it should be 16 bytes (32 ascii chars)"
            ))
        }
    }

    pub fn tiny_hash(&self) -> String {
        format!("{self:x}")[..7].to_string()
    }

    pub fn value(&self) -> [u8; 16] {
        self.0
    }
}

impl Display for ShortHash {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:x}")
    }
}

impl Debug for ShortHash {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:x}")
    }
}

impl LowerHex for ShortHash {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let hex = hex::encode(self.0);
        write!(f, "{hex}")?;
        Ok(())
    }
}

#[pyclass]
pub(crate) struct StdOutLog;

#[pymethods]
impl StdOutLog {
    pub(crate) fn write(&self, data: &str) {
        let data = data.trim();
        if !data.is_empty() {
            info!("python: {data:?}");
        }
    }
}

#[pyclass]
pub(crate) struct StdErrLog;

#[pymethods]
impl StdErrLog {
    pub(crate) fn write(&self, data: &str) {
        let data = data.trim();
        if !data.is_empty() {
            error!("python: {data:?}");
        }
    }
}