nostro2-nips 0.2.0

Nostro2 is a simple toolset for interacting with 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

#![warn(
    clippy::all,
    clippy::missing_errors_doc,
    clippy::style,
    clippy::unseparated_literal_suffix,
    clippy::pedantic,
    clippy::nursery
)]
mod nip_04;
mod nip_17;
mod nip_44;
mod nip_46;
mod nip_59;
mod nip_82;

pub use nip_04::*;
pub use nip_17::*;
pub use nip_44::*;
pub use nip_46::*;
pub use nip_59::*;
pub use nip_82::*;
#[cfg(test)]
mod tests {
    use k256::schnorr::signature::hazmat::PrehashSigner;

    pub struct NipTester {
        pub signing_key: k256::schnorr::SigningKey,
    }
    impl crate::Nip04 for NipTester {
        fn shared_secret(
            &self,
            pubkey: &str,
        ) -> Result<zeroize::Zeroizing<[u8; 32]>, crate::Nip04Error> {
            let hex_pk = hex::decode(pubkey)?;
            // Build compressed SEC1 point: 0x02 prefix (even parity) + 32-byte x-coordinate
            let mut compressed = [0_u8; 33];
            compressed[0] = 0x02;
            compressed[1..].copy_from_slice(&hex_pk);
            let public_key = k256::PublicKey::from_sec1_bytes(&compressed)
                .map_err(|_| crate::Nip04Error::SharedSecretError)?;
            let secret_key = k256::SecretKey::from_slice(&self.signing_key.to_bytes())
                .map_err(|_| crate::Nip04Error::SharedSecretError)?;
            let shared =
                k256::ecdh::diffie_hellman(secret_key.to_nonzero_scalar(), public_key.as_affine());
            let mut point = [0_u8; 32];
            point.copy_from_slice(shared.raw_secret_bytes().as_slice());
            Ok(point.into())
        }
    }
    impl crate::Nip44 for NipTester {
        fn shared_secret(
            &self,
            pubkey: &str,
        ) -> Result<zeroize::Zeroizing<[u8; 32]>, crate::Nip44Error> {
            let hex_pk = hex::decode(pubkey)?;
            // Build compressed SEC1 point: 0x02 prefix (even parity) + 32-byte x-coordinate
            let mut compressed = [0_u8; 33];
            compressed[0] = 0x02;
            compressed[1..].copy_from_slice(&hex_pk);
            let public_key = k256::PublicKey::from_sec1_bytes(&compressed)
                .map_err(|_| crate::Nip44Error::SharedSecretError)?;
            let secret_key = k256::SecretKey::from_slice(&self.signing_key.to_bytes())
                .map_err(|_| crate::Nip44Error::SharedSecretError)?;
            let shared =
                k256::ecdh::diffie_hellman(secret_key.to_nonzero_scalar(), public_key.as_affine());
            let mut point = [0_u8; 32];
            point.copy_from_slice(shared.raw_secret_bytes().as_slice());
            Ok(point.into())
        }
    }
    impl nostro2::NostrSigner for NipTester {
        fn secret_key(&self) -> String {
            hex::encode(self.signing_key.to_bytes())
        }
        fn sign_nostr_note(
            &self,
            note: &mut nostro2::NostrNote,
        ) -> Result<(), nostro2::errors::NostrErrors> {
            note.pubkey = self.public_key();
            note.serialize_id()?;
            let id = note.id_bytes().unwrap_or([0_u8; 32]);
            let sig = self
                .signing_key
                .sign_prehash(&id)
                .map_err(|_| nostro2::errors::NostrErrors::InvalidSignature)?;
            note.sig.replace(hex::encode(sig.to_bytes()));
            Ok(())
        }
        fn generate(_extractable: bool) -> Self {
            Self {
                signing_key: k256::schnorr::SigningKey::random(&mut rand_core::OsRng),
            }
        }
        fn public_key(&self) -> String {
            hex::encode(self.signing_key.verifying_key().to_bytes())
        }
    }
    impl crate::Nip17 for NipTester {}
    impl crate::Nip46 for NipTester {}
    impl crate::Nip59 for NipTester {}
    impl crate::Nip82 for NipTester {}
    impl NipTester {
        pub fn _peer_one() -> Self {
            let bytes = hex::decode("30af2e27172df3fa2c202cf6a49bed35a2e0cb7994d9b437b2d945a92824c22a")
                .unwrap();
            let field_bytes = k256::FieldBytes::from_slice(&bytes);
            let signing_key = k256::schnorr::SigningKey::from_bytes(field_bytes).unwrap();
            Self { signing_key }
        }
        pub fn _peer_two() -> Self {
            let bytes = hex::decode("dd33562d81e8d00bfbe14708acdff85dffe6e6b6ca073ba3acdc6adb140cb8f1")
                .unwrap();
            let field_bytes = k256::FieldBytes::from_slice(&bytes);
            let signing_key = k256::schnorr::SigningKey::from_bytes(field_bytes).unwrap();
            Self { signing_key }
        }
        pub fn _peer_three() -> Self {
            let bytes = hex::decode("3410d9bd915643276a30795d4669a93469810a76901ce58f148c2cb84fcdc1b6")
                .unwrap();
            let field_bytes = k256::FieldBytes::from_slice(&bytes);
            let signing_key = k256::schnorr::SigningKey::from_bytes(field_bytes).unwrap();
            Self { signing_key }
        }
    }
    impl std::str::FromStr for NipTester {
        type Err = ();
        fn from_str(s: &str) -> Result<Self, Self::Err> {
            let bytes = hex::decode(s).map_err(|_| ())?;
            let field_bytes = k256::FieldBytes::from_slice(&bytes);
            let signing_key = k256::schnorr::SigningKey::from_bytes(field_bytes).map_err(|_| ())?;
            Ok(Self { signing_key })
        }
    }
}