nostr 0.45.3

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

//! Nostr error.

use alloc::boxed::Box;
use alloc::string::{String, ToString};
use core::{error, fmt};

opaquerr::define_kind! {
    /// Nostr error kind.
    pub ErrorKind {
        /// Input is not well-formed and cannot be parsed.
        Malformed => "input is malformed",
        /// Input is well-formed, but violates a protocol/library invariant.
        Invalid => "input violates a protocol/library invariant",
        /// Required data is missing.
        Missing => "required data is missing",
        /// The value/operation is known but not supported.
        Unsupported => "the value/operation is known but not supported",
        /// Cryptographic operation failed.
        Crypto => "cryptographic operation failed.",
        /// Anything not covered by the stable categories above.
        Other => "other error",
    }
}

opaquerr::define_error! {
    /// Nostr error.
    pub Error(ErrorKind)

    from {
        serde_json::Error => ErrorKind::Malformed,
    }
}

#[derive(Debug)]
struct DisplayError(String);

impl fmt::Display for DisplayError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.0)
    }
}

impl error::Error for DisplayError {}

impl Error {
    #[inline]
    pub(crate) fn invalid<E>(error: E) -> Self
    where
        E: Into<Box<dyn error::Error + Send + Sync>>,
    {
        Self::new(ErrorKind::Invalid, error.into())
    }

    #[inline]
    pub(crate) fn invalid_display<E>(error: E) -> Self
    where
        E: fmt::Display,
    {
        Self::invalid(DisplayError(error.to_string()))
    }

    #[inline]
    pub(crate) fn malformed<E>(error: E) -> Self
    where
        E: Into<Box<dyn error::Error + Send + Sync>>,
    {
        Self::new(ErrorKind::Malformed, error.into())
    }

    #[inline]
    pub(crate) fn malformed_display<E>(error: E) -> Self
    where
        E: fmt::Display,
    {
        Self::malformed(DisplayError(error.to_string()))
    }

    #[inline]
    #[cfg(any(feature = "nip46", feature = "nip59"))]
    pub(crate) fn crypto<E>(error: E) -> Self
    where
        E: Into<Box<dyn error::Error + Send + Sync>>,
    {
        Self::new(ErrorKind::Crypto, error.into())
    }

    #[inline]
    #[cfg(feature = "nip49")]
    pub(crate) fn crypto_display<E>(error: E) -> Self
    where
        E: fmt::Display,
    {
        Self::crypto(DisplayError(error.to_string()))
    }

    /// Creates a new Nostr error from a known kind of error as well as an arbitrary error payload.
    ///
    /// It is a shortcut for [`Error::new`] with [`ErrorKind::Other`].
    #[inline]
    pub fn other<E>(error: E) -> Self
    where
        E: Into<Box<dyn error::Error + Send + Sync>>,
    {
        Self::new(ErrorKind::Other, error.into())
    }
}