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 = 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 = 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 }
99
100