dpp/identity/identity_public_key/
mod.rs

1#![allow(clippy::from_over_into)]
2
3use crate::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
4use crate::identity::identity_public_key::v0::IdentityPublicKeyV0;
5#[cfg(feature = "value-conversion")]
6use crate::serialization::ValueConvertible;
7use bincode::{Decode, Encode};
8use derive_more::From;
9use serde::{Deserialize, Serialize};
10
11mod key_type;
12mod purpose;
13mod security_level;
14pub use key_type::KeyType;
15pub use purpose::Purpose;
16pub use security_level::SecurityLevel;
17pub mod accessors;
18pub mod conversion;
19pub mod fields;
20pub mod v0;
21use crate::version::PlatformVersion;
22use crate::ProtocolError;
23pub use fields::*;
24use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
25
26pub mod methods;
27pub use methods::*;
28pub mod contract_bounds;
29#[cfg(feature = "random-public-keys")]
30mod random;
31
32pub type KeyID = u32;
33pub type KeyCount = KeyID;
34pub type TimestampMillis = u64;
35
36#[derive(
37    Debug,
38    Clone,
39    Eq,
40    PartialEq,
41    Serialize,
42    Deserialize,
43    Encode,
44    Decode,
45    PlatformDeserialize,
46    PlatformSerialize,
47    From,
48    Hash,
49    Ord,
50    PartialOrd,
51)]
52#[platform_serialize(limit = 2000, unversioned)] //This is not platform versioned automatically
53#[cfg_attr(feature = "value-conversion", derive(ValueConvertible))]
54#[serde(tag = "$formatVersion")]
55pub enum IdentityPublicKey {
56    #[serde(rename = "0")]
57    V0(IdentityPublicKeyV0),
58}
59
60impl IdentityPublicKey {
61    /// Checks if public key security level is MASTER
62    pub fn is_master(&self) -> bool {
63        self.security_level() == SecurityLevel::MASTER
64    }
65
66    /// Generates an identity public key with the maximum possible size based on the platform version.
67    ///
68    /// This method constructs a key of the largest possible size for the given platform version.
69    /// This can be useful for stress testing or benchmarking purposes.
70    ///
71    /// # Parameters
72    ///
73    /// * `id`: The `KeyID` for the generated key.
74    /// * `platform_version`: The platform version which determines the structure of the identity key.
75    ///
76    /// # Returns
77    ///
78    /// * `Self`: An instance of the `IdentityPublicKey` struct.
79    ///
80    pub fn max_possible_size_key(
81        id: KeyID,
82        platform_version: &PlatformVersion,
83    ) -> Result<Self, ProtocolError> {
84        match platform_version
85            .dpp
86            .identity_versions
87            .identity_key_structure_version
88        {
89            0 => Ok(IdentityPublicKeyV0::max_possible_size_key(id).into()),
90            version => Err(ProtocolError::UnknownVersionMismatch {
91                method: "IdentityPublicKey::max_possible_size_key".to_string(),
92                known_versions: vec![0],
93                received: version,
94            }),
95        }
96    }
97
98    pub fn default_versioned(platform_version: &PlatformVersion) -> Result<Self, ProtocolError> {
99        match platform_version
100            .dpp
101            .identity_versions
102            .identity_key_structure_version
103        {
104            0 => Ok(IdentityPublicKeyV0::default().into()),
105            version => Err(ProtocolError::UnknownVersionMismatch {
106                method: "IdentityPublicKey::default_versioned".to_string(),
107                known_versions: vec![0],
108                received: version,
109            }),
110        }
111    }
112}
113
114#[cfg(test)]
115mod tests {
116    use crate::identity::identity_public_key::v0::IdentityPublicKeyV0;
117    use crate::identity::IdentityPublicKey;
118    use crate::serialization::{PlatformDeserializable, PlatformSerializable};
119    use platform_version::version::LATEST_PLATFORM_VERSION;
120    use rand::SeedableRng;
121
122    #[test]
123    fn test_identity_key_serialization_deserialization() {
124        let mut rng = rand::rngs::StdRng::from_entropy();
125        let key: IdentityPublicKey =
126            IdentityPublicKeyV0::random_ecdsa_master_authentication_key_with_rng(
127                1,
128                &mut rng,
129                LATEST_PLATFORM_VERSION,
130            )
131            .expect("expected a random key")
132            .0
133            .into();
134        let serialized = key.serialize_to_bytes().expect("expected to serialize key");
135        let unserialized: IdentityPublicKey =
136            PlatformDeserializable::deserialize_from_bytes(serialized.as_slice())
137                .expect("expected to deserialize key");
138        assert_eq!(key, unserialized)
139    }
140}
dpp/identity/identity_public_key/mod.rs

dpp/identity/identity_public_key/
mod.rs
