dpp/identity/v0/
mod.rs

1mod conversion;
2#[cfg(feature = "random-identities")]
3pub mod random;
4
5#[cfg(feature = "json-conversion")]
6use crate::serialization::json_safe_fields;
7#[cfg(feature = "value-conversion")]
8use crate::serialization::ValueConvertible;
9use std::collections::BTreeMap;
10#[cfg(feature = "value-conversion")]
11use std::convert::TryFrom;
12use std::hash::{Hash, Hasher};
13
14use crate::identity::{IdentityPublicKey, KeyID, PartialIdentity};
15use crate::prelude::Revision;
16#[cfg(feature = "value-conversion")]
17use platform_value::Value;
18
19#[cfg(feature = "value-conversion")]
20use crate::errors::ProtocolError;
21use crate::identifier::Identifier;
22#[cfg(feature = "identity-serialization")]
23use bincode::{Decode, Encode};
24
25/// Implement the Identity. Identity is a low-level construct that provides the foundation
26/// for user-facing functionality on the platform
27#[cfg_attr(feature = "json-conversion", json_safe_fields)]
28#[derive(Default, Debug, Clone, Eq, PartialEq)]
29#[cfg_attr(feature = "identity-serialization", derive(Encode, Decode))]
30#[cfg_attr(
31    any(feature = "serde-conversion", feature = "serde-conversion"),
32    derive(serde::Serialize, serde::Deserialize),
33    serde(rename_all = "camelCase")
34)]
35#[cfg_attr(feature = "value-conversion", derive(ValueConvertible))]
36pub struct IdentityV0 {
37    pub id: Identifier,
38    #[cfg_attr(
39        any(feature = "serde-conversion", feature = "serde-conversion"),
40        serde(with = "public_key_serialization")
41    )]
42    pub public_keys: BTreeMap<KeyID, IdentityPublicKey>,
43    pub balance: u64,
44    pub revision: Revision,
45}
46
47impl Hash for IdentityV0 {
48    fn hash<H: Hasher>(&self, state: &mut H) {
49        self.id.hash(state);
50    }
51}
52
53mod public_key_serialization {
54    use crate::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
55    use crate::identity::{IdentityPublicKey, KeyID};
56    use serde::ser::SerializeSeq;
57    use serde::{Deserialize, Serializer};
58    use std::collections::BTreeMap;
59
60    /// deserialize_public_keys deserializes public keys from a vector
61    pub fn deserialize<'de, D>(
62        deserializer: D,
63    ) -> Result<BTreeMap<KeyID, IdentityPublicKey>, D::Error>
64    where
65        D: serde::Deserializer<'de>,
66    {
67        let public_key_vec: Vec<IdentityPublicKey> = Deserialize::deserialize(deserializer)?;
68        Ok(public_key_vec.into_iter().map(|k| (k.id(), k)).collect())
69    }
70
71    pub fn serialize<S>(
72        public_keys: &BTreeMap<KeyID, IdentityPublicKey>,
73        serializer: S,
74    ) -> Result<S::Ok, S::Error>
75    where
76        S: Serializer,
77    {
78        let mut seq = serializer.serialize_seq(Some(public_keys.len()))?;
79        for element in public_keys.values() {
80            seq.serialize_element(element)?;
81        }
82        seq.end()
83    }
84}
85
86impl IdentityV0 {
87    /// Get Identity protocol version
88    pub fn get_feature_version(&self) -> u16 {
89        0
90    }
91
92    /// Convenience method to get Partial Identity Info
93    pub fn into_partial_identity_info(self) -> PartialIdentity {
94        let Self {
95            id,
96            public_keys,
97            balance,
98            revision,
99            ..
100        } = self;
101        PartialIdentity {
102            id,
103            loaded_public_keys: public_keys,
104            balance: Some(balance),
105            revision: Some(revision),
106            not_found_public_keys: Default::default(),
107        }
108    }
109
110    /// Convenience method to get Partial Identity Info
111    pub fn into_partial_identity_info_no_balance(self) -> PartialIdentity {
112        let Self {
113            id,
114            public_keys,
115            revision,
116            ..
117        } = self;
118        PartialIdentity {
119            id,
120            loaded_public_keys: public_keys,
121            balance: None,
122            revision: Some(revision),
123            not_found_public_keys: Default::default(),
124        }
125    }
126}
127
128#[cfg(feature = "value-conversion")]
129impl TryFrom<Value> for IdentityV0 {
130    type Error = ProtocolError;
131
132    fn try_from(value: Value) -> Result<Self, Self::Error> {
133        platform_value::from_value(value).map_err(ProtocolError::ValueError)
134    }
135}
136
137#[cfg(feature = "value-conversion")]
138impl TryFrom<&Value> for IdentityV0 {
139    type Error = ProtocolError;
140
141    fn try_from(value: &Value) -> Result<Self, Self::Error> {
142        platform_value::from_value(value.clone()).map_err(ProtocolError::ValueError)
143    }
144}
dpp/identity/v0/mod.rs

dpp/identity/v0/
mod.rs
