cashu/nuts/nut01/
public_key.rs

1use core::fmt;
2use core::ops::Deref;
3use core::str::FromStr;
4
5use bitcoin::hashes::sha256::Hash as Sha256Hash;
6use bitcoin::hashes::Hash;
7use bitcoin::secp256k1::schnorr::Signature;
8use bitcoin::secp256k1::{self, Message, XOnlyPublicKey};
9use serde::{Deserialize, Deserializer, Serialize};
10
11use super::Error;
12use crate::SECP256K1;
13
14/// PublicKey
15#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
16#[cfg_attr(feature = "swagger", derive(utoipa::ToSchema))]
17pub struct PublicKey {
18    #[cfg_attr(feature = "swagger", schema(value_type = String))]
19    inner: secp256k1::PublicKey,
20}
21
22impl fmt::Debug for PublicKey {
23    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
24        write!(f, "PublicKey({})", self.to_hex())
25    }
26}
27
28impl Deref for PublicKey {
29    type Target = secp256k1::PublicKey;
30
31    fn deref(&self) -> &Self::Target {
32        &self.inner
33    }
34}
35
36impl From<secp256k1::PublicKey> for PublicKey {
37    fn from(inner: secp256k1::PublicKey) -> Self {
38        Self { inner }
39    }
40}
41
42impl PublicKey {
43    /// Parse from `bytes`
44    #[inline]
45    pub fn from_slice(slice: &[u8]) -> Result<Self, Error> {
46        Ok(Self {
47            inner: secp256k1::PublicKey::from_slice(slice)?,
48        })
49    }
50
51    /// Parse from `hex` string
52    #[inline]
53    pub fn from_hex<S>(hex: S) -> Result<Self, Error>
54    where
55        S: AsRef<str>,
56    {
57        let hex: &str = hex.as_ref();
58
59        // Check size
60        if hex.len() != 33 * 2 {
61            return Err(Error::InvalidPublicKeySize {
62                expected: 33,
63                found: hex.len() / 2,
64            });
65        }
66
67        Ok(Self {
68            inner: secp256k1::PublicKey::from_str(hex)?,
69        })
70    }
71
72    /// [`PublicKey`] to bytes
73    #[inline]
74    pub fn to_bytes(&self) -> [u8; 33] {
75        self.inner.serialize()
76    }
77
78    /// To uncompressed bytes
79    #[inline]
80    pub fn to_uncompressed_bytes(&self) -> [u8; 65] {
81        self.inner.serialize_uncompressed()
82    }
83
84    /// To [`XOnlyPublicKey`]
85    #[inline]
86    pub fn x_only_public_key(&self) -> XOnlyPublicKey {
87        self.inner.x_only_public_key().0
88    }
89
90    /// Get public key as `hex` string
91    #[inline]
92    pub fn to_hex(&self) -> String {
93        self.inner.to_string()
94    }
95
96    /// Verify schnorr signature
97    pub fn verify(&self, msg: &[u8], sig: &Signature) -> Result<(), Error> {
98        let hash: Sha256Hash = Sha256Hash::hash(msg);
99        let msg = Message::from_digest_slice(hash.as_ref())?;
100        SECP256K1.verify_schnorr(sig, &msg, &self.inner.x_only_public_key().0)?;
101        Ok(())
102    }
103}
104
105impl FromStr for PublicKey {
106    type Err = Error;
107
108    fn from_str(hex: &str) -> Result<Self, Self::Err> {
109        Self::from_hex(hex)
110    }
111}
112
113impl fmt::Display for PublicKey {
114    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
115        write!(f, "{}", self.to_hex())
116    }
117}
118
119impl Serialize for PublicKey {
120    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
121    where
122        S: serde::Serializer,
123    {
124        serializer.serialize_str(&self.to_hex())
125    }
126}
127
128impl<'de> Deserialize<'de> for PublicKey {
129    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
130    where
131        D: Deserializer<'de>,
132    {
133        let public_key: String = String::deserialize(deserializer)?;
134        Self::from_hex(public_key).map_err(serde::de::Error::custom)
135    }
136}
137
138#[cfg(test)]
139mod tests {
140    use super::*;
141
142    #[test]
143    pub fn test_public_key_from_hex() {
144        // Compressed
145        assert!(PublicKey::from_hex(
146            "02194603ffa36356f4a56b7df9371fc3192472351453ec7398b8da8117e7c3e104"
147        )
148        .is_ok());
149    }
150
151    #[test]
152    pub fn test_invalid_public_key_from_hex() {
153        // Uncompressed (is valid but is cashu must be compressed?)
154        assert!(PublicKey::from_hex("04fd4ce5a16b65576145949e6f99f445f8249fee17c606b688b504a849cdc452de3625246cb2c27dac965cb7200a5986467eee92eb7d496bbf1453b074e223e481")
155            .is_err())
156    }
157}
158
159#[cfg(all(feature = "bench", test))]
160mod benches {
161    extern crate test;
162    use test::{black_box, Bencher};
163
164    use super::*;
165
166    const HEX: &str = "02194603ffa36356f4a56b7df9371fc3192472351453ec7398b8da8117e7c3e104";
167
168    #[bench]
169    pub fn public_key_from_hex(bh: &mut Bencher) {
170        bh.iter(|| {
171            black_box(PublicKey::from_hex(HEX)).unwrap();
172        });
173    }
174}
cashu/nuts/nut01/public_key.rs

cashu/nuts/nut01/
public_key.rs
