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

use serde::{Deserialize, Serialize};
use serde_bytes::ByteBuf;

use crate::sign_schema::SignatureSchema;
use crate::PublicKey;

/// Reset the main secret key
#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
pub struct ResetMainSecret {
    /// Signature schema
    pub sign_schema: SignatureSchema,

    /// Encrypted private key of the new main secret
    pub encrypted_pri_key: ByteBuf,

    /// Public key of the new main secret
    pub l2_pub_key: PublicKey,
}

/// Create API secret
#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
#[serde(transparent)]
pub struct CreateApiSecret(pub PublicKey);

/// Destroy API secret
#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
#[serde(transparent)]
pub struct DestroyApiSecret(pub PublicKey);

#[cfg(test)]
mod tests {
    use ex3_serde::bincode;

    use super::*;

    #[test]
    fn test_reset_main_secret_serde() {
        let reset_main_secret = ResetMainSecret {
            sign_schema: SignatureSchema::EvmEcdsa,
            encrypted_pri_key: ByteBuf::from(vec![1, 2, 3]),
            l2_pub_key: PublicKey::from([1u8; 32]),
        };
        // bincode
        let encoded = bincode::serialize(&reset_main_secret).unwrap();
        let decoded: ResetMainSecret = bincode::deserialize(&encoded).unwrap();
        assert_eq!(reset_main_secret, decoded);

        // cbor
        let encoded = bincode::serialize(&reset_main_secret).unwrap();
        let decoded: ResetMainSecret = bincode::deserialize(&encoded).unwrap();
        assert_eq!(reset_main_secret, decoded);
    }

    #[test]
    fn test_create_api_secret_serde() {
        let create_api_secret = CreateApiSecret(PublicKey::from([1u8; 32]));
        // bincode
        let encoded = bincode::serialize(&create_api_secret).unwrap();
        let decoded: CreateApiSecret = bincode::deserialize(&encoded).unwrap();
        assert_eq!(create_api_secret, decoded);

        // cbor
        let encoded = bincode::serialize(&create_api_secret).unwrap();
        let decoded: CreateApiSecret = bincode::deserialize(&encoded).unwrap();
        assert_eq!(create_api_secret, decoded);
    }

    #[test]
    fn test_destroy_api_secret_serde() {
        let destroy_api_secret = DestroyApiSecret(PublicKey::from([1u8; 32]));
        // bincode
        let encoded = bincode::serialize(&destroy_api_secret).unwrap();
        let decoded: DestroyApiSecret = bincode::deserialize(&encoded).unwrap();
        assert_eq!(destroy_api_secret, decoded);

        // cbor
        let encoded = bincode::serialize(&destroy_api_secret).unwrap();
        let decoded: DestroyApiSecret = bincode::deserialize(&encoded).unwrap();
        assert_eq!(destroy_api_secret, decoded);
    }
}