nostr_rust 0.20.3

A Rust implementation of the Nostr protocol
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
145
146
147
148
149
150
151
152

use bech32::{FromBase32, ToBase32};
use hex::FromHexError;
use thiserror::Error;

pub enum ToBech32Kind {
    SecretKey,
    PublicKey,
    Note,
}

#[derive(Error, Debug, Eq, PartialEq)]
pub enum Bech32Error {
    #[error("Invalid hex string")]
    InvalidHex,

    #[error("Bech32 given key is not a {0}")]
    InvalidKey(String),
}

impl From<bech32::Error> for Bech32Error {
    fn from(_err: bech32::Error) -> Self {
        Self::InvalidHex
    }
}

impl From<FromHexError> for Bech32Error {
    fn from(_err: hex::FromHexError) -> Self {
        Self::InvalidHex
    }
}

/// Transform a string (bech32 or hex) into an bech32 string
///
/// # Example
/// ```rust
/// use nostr_rust::bech32::{ToBech32Kind, to_bech32};
/// let bech32 = to_bech32(ToBech32Kind::PublicKey, "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d");
/// assert_eq!(bech32.unwrap(), "npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6");
/// ```
pub fn to_bech32(kind: ToBech32Kind, key: &str) -> Result<String, Bech32Error> {
    let key = key.to_string();

    match kind {
        ToBech32Kind::SecretKey => {
            if key.starts_with("nsec") {
                Ok(key)
            } else if key.starts_with("npub") || key.starts_with("note") {
                return Err(Bech32Error::InvalidKey("npub or note".to_string()));
            } else {
                return Ok(bech32::encode(
                    "nsec",
                    hex::decode(key)?.to_base32(),
                    bech32::Variant::Bech32,
                )?);
            }
        }
        ToBech32Kind::PublicKey => {
            if key.starts_with("npub") {
                Ok(key)
            } else if key.starts_with("nsec") || key.starts_with("note") {
                return Err(Bech32Error::InvalidKey("nsec or note".to_string()));
            } else {
                return Ok(bech32::encode(
                    "npub",
                    hex::decode(key)?.to_base32(),
                    bech32::Variant::Bech32,
                )?);
            }
        }
        ToBech32Kind::Note => {
            if key.starts_with("note") {
                Ok(key)
            } else if key.starts_with("nsec") || key.starts_with("npub") {
                return Err(Bech32Error::InvalidKey("nsec or npub".to_string()));
            } else {
                return Ok(bech32::encode(
                    "note",
                    hex::decode(key)?.to_base32(),
                    bech32::Variant::Bech32,
                )?);
            }
        }
    }
}

/// (hb for hex and bech32) Transform a string (bech32 or hex) into an hex string
/// # Example
/// ```rust
/// use nostr_rust::bech32::{ToBech32Kind, from_hb_to_hex};
/// let hex = from_hb_to_hex(ToBech32Kind::PublicKey, "npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6");
/// assert_eq!(hex.unwrap(), "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d");
/// ```
pub fn from_hb_to_hex(kind: ToBech32Kind, key: &str) -> Result<String, Bech32Error> {
    let key = key.to_string();

    match kind {
        ToBech32Kind::SecretKey => {
            if key.starts_with("nsec") {
                let data = bech32::decode(&key)?.1;
                let decoded = Vec::<u8>::from_base32(&data)?;
                let hex_str = hex::encode(decoded);

                Ok(hex_str)
            } else if key.starts_with("npub") {
                return Err(Bech32Error::InvalidKey("npub".to_string()));
            } else {
                return Ok(key);
            }
        }
        ToBech32Kind::PublicKey => {
            if key.starts_with("npub") {
                let data = bech32::decode(&key)?.1;
                let decoded = Vec::<u8>::from_base32(&data)?;
                let hex_str = hex::encode(decoded);

                Ok(hex_str)
            } else if key.starts_with("nsec") {
                return Err(Bech32Error::InvalidKey("nsec".to_string()));
            } else {
                return Ok(key);
            }
        }
        ToBech32Kind::Note => {
            if key.starts_with("note") {
                let data = bech32::decode(&key)?.1;
                let decoded = Vec::<u8>::from_base32(&data)?;
                let hex_str = hex::encode(decoded);

                Ok(hex_str)
            } else if key.starts_with("nsec") || key.starts_with("npub") {
                return Err(Bech32Error::InvalidKey("nsec or npub".to_string()));
            } else {
                return Ok(key);
            }
        }
    }
}

/// Transform a string (bech32 or hex) into an hex string
pub fn auto_bech32_to_hex(key: &str) -> Result<String, Bech32Error> {
    let key = key.to_string();

    if key.starts_with("nsec") {
        from_hb_to_hex(ToBech32Kind::SecretKey, &key)
    } else if key.starts_with("npub") {
        from_hb_to_hex(ToBech32Kind::PublicKey, &key)
    } else if key.starts_with("note") {
        from_hb_to_hex(ToBech32Kind::Note, &key)
    } else {
        Ok(key)
    }
}