Skip to main content

keypair_rs/
keypair.rs

1use crate::crypto::hash;
2
3use secp256k1::hashes::sha256;
4use secp256k1::{Message, PublicKey,SecretKey, Secp256k1, ecdsa::Signature as Signature};
5use rand::rngs::OsRng;
6
7#[derive(Debug, Clone)]
8pub struct Keypair {
9    pub public_key: String,
10    pub private_key: String,
11}
12
13impl Keypair {
14    pub fn address(&self) -> String {
15        format!(
16            "0x{}",
17            hash(hex::decode(&self.public_key).unwrap())[..40].to_string()
18        )
19    }
20
21    pub fn generate() -> Self {
22        let secp = Secp256k1::new();
23        let mut rng = OsRng;
24        let (secret_key, public_key) = secp.generate_keypair(&mut rng);
25        Keypair {
26            private_key: secret_key.display_secret().to_string(),
27            public_key: public_key.to_string(),
28        }
29    }
30
31    pub fn sign(&self, message: String) -> Result<String, Box<dyn std::error::Error>> {
32        let secp = Secp256k1::new();
33        let a = hex::decode(&self.private_key).unwrap();
34        // let secretkey = secp256k1::key::SecretKey::from_slice(&a);
35        let secretkey = SecretKey::from_slice(&a);
36        let msg = Message::from_hashed_data::<sha256::Hash>(message.as_bytes());
37        let sig = secp.sign_ecdsa(&msg, &secretkey.unwrap());
38        Ok(hex::encode(sig.serialize_der().to_vec()))
39    }
40
41    pub fn verify(
42        &self,
43        message: &String,
44        signature: &String,
45    ) -> Result<bool, Box<dyn std::error::Error>> {
46        let sig_bytes = hex::decode(signature)?;
47        let signature: Signature = Signature::from_der(&sig_bytes)?;
48        let secp = Secp256k1::new();
49        let pk_bytes = hex::decode(self.public_key.as_bytes());
50        let publickey = PublicKey::from_slice(&pk_bytes.unwrap())?;
51        let msg = Message::from_hashed_data::<sha256::Hash>(message.as_bytes());
52        return Ok(secp.verify_ecdsa(&msg, &signature, &publickey).is_ok());
53    }
54
55    pub fn from_private_key(pk: String) -> Keypair {
56        let privatekeyclone = pk.clone();
57        let a = hex::decode(&pk).unwrap();
58        let secretkey = SecretKey::from_slice(&a);
59        let secp = &Secp256k1::new();
60        // let public_key = secp256k1::key::PublicKey::from_secret_key(secp, &secretkey.unwrap());
61        let public_key = PublicKey::from_secret_key(secp, &secretkey.unwrap());
62        Keypair {
63            private_key: privatekeyclone.to_string(),
64            public_key: public_key.to_string(),
65        }
66    }
67}
68
69#[cfg(test)]
70mod tests {
71    use super::*;
72
73    #[test]
74    fn test_keypair() {
75        let keypair = Keypair::generate();
76        let message = "hello world".to_string();
77        let signature = keypair.sign(message.clone()).unwrap();
78        assert!(keypair.verify(&message, &signature).unwrap());
79        println!("keypair: {:?}", keypair);
80        println!("address: {:?}", keypair.address());
81
82    }
83    #[test]
84    fn test_from_private_key() {
85        let keypair = Keypair::generate();
86        let keypair2 = Keypair::from_private_key(keypair.private_key.clone());
87        assert_eq!(keypair.private_key, keypair2.private_key);
88        assert_eq!(keypair.public_key, keypair2.public_key);
89        println!("keypair: {:?}", keypair);
90    }
91    #[test]
92    fn test_address() {
93        let keypair = Keypair::generate();
94        let address = keypair.address();
95        println!("address: {:?}", address);
96    }
97    // cargo test -- --nocapture
98}
99
100