lockbook_shared/
account.rs1use crate::pubkey;
2use libsecp256k1::{PublicKey, SecretKey};
3use serde::{Deserialize, Serialize};
4
5pub const MAX_USERNAME_LENGTH: usize = 32;
6
7pub type Username = String;
8pub type ApiUrl = String;
9
10#[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
11pub struct Account {
12 pub username: Username,
13 pub api_url: ApiUrl,
14 #[serde(with = "secret_key_serializer")]
15 pub private_key: SecretKey,
16}
17
18impl Account {
19 pub fn new(username: String, api_url: String) -> Self {
20 let private_key = pubkey::generate_key();
21 Self { username, api_url, private_key }
22 }
23
24 pub fn public_key(&self) -> PublicKey {
25 PublicKey::from_secret_key(&self.private_key)
26 }
27}
28
29pub mod secret_key_serializer {
30 use libsecp256k1::SecretKey;
31 use serde::de::Deserialize;
32 use serde::de::Deserializer;
33 use serde::ser::Serializer;
34
35 pub fn serialize<S>(sk: &SecretKey, serializer: S) -> Result<S::Ok, S::Error>
36 where
37 S: Serializer,
38 {
39 serializer.serialize_bytes(&sk.serialize())
40 }
41
42 pub fn deserialize<'de, D>(deserializer: D) -> Result<SecretKey, D::Error>
43 where
44 D: Deserializer<'de>,
45 {
46 let key = <Vec<u8>>::deserialize(deserializer)?;
47 let sk = SecretKey::parse_slice(&key).map_err(serde::de::Error::custom)?;
48 Ok(sk)
49 }
50}
51
52#[cfg(test)]
53mod test_account_serialization {
54 use libsecp256k1::SecretKey;
55 use rand::rngs::OsRng;
56
57 use crate::account::Account;
58
59 #[test]
60 fn account_serialize_deserialize() {
61 let account1 = Account {
62 username: "test".to_string(),
63 api_url: "test.com".to_string(),
64 private_key: SecretKey::random(&mut OsRng),
65 };
66
67 let encoded: Vec<u8> = bincode::serialize(&account1).unwrap();
68 let account2: Account = bincode::deserialize(&encoded).unwrap();
69
70 assert_eq!(account1, account2);
71 }
72}