drive/state_transition_action/identity/identity_create/
mod.rs

1/// transformer
2pub mod transformer;
3/// v0
4pub mod v0;
5
6use crate::state_transition_action::identity::identity_create::v0::{
7    IdentityCreateTransitionActionV0, IdentityFromIdentityCreateTransitionActionV0,
8};
9use derive_more::From;
10use dpp::asset_lock::reduced_asset_lock_value::AssetLockValue;
11use dpp::identity::{Identity, IdentityPublicKey, PartialIdentity};
12use dpp::platform_value::{Bytes36, Identifier};
13use dpp::prelude::UserFeeIncrease;
14use dpp::version::PlatformVersion;
15use dpp::ProtocolError;
16
17/// action
18#[derive(Debug, Clone, From)]
19pub enum IdentityCreateTransitionAction {
20    /// v0
21    V0(IdentityCreateTransitionActionV0),
22}
23
24/// action
25impl IdentityCreateTransitionAction {
26    /// Public Keys
27    pub fn public_keys(&self) -> &Vec<IdentityPublicKey> {
28        match self {
29            IdentityCreateTransitionAction::V0(transition) => &transition.public_keys,
30        }
31    }
32
33    /// Asset lock value to be consumed
34    /// The initial balance is equal to the remaining credit value in the asset lock value
35    pub fn asset_lock_value_to_be_consumed(&self) -> &AssetLockValue {
36        match self {
37            IdentityCreateTransitionAction::V0(transition) => {
38                &transition.asset_lock_value_to_be_consumed
39            }
40        }
41    }
42
43    /// Asset lock value to be consumed
44    /// The initial balance is equal to the remaining credit value in the asset lock value
45    pub fn asset_lock_value_to_be_consumed_owned(self) -> AssetLockValue {
46        match self {
47            IdentityCreateTransitionAction::V0(transition) => {
48                transition.asset_lock_value_to_be_consumed
49            }
50        }
51    }
52
53    /// Identity Id
54    pub fn identity_id(&self) -> Identifier {
55        match self {
56            IdentityCreateTransitionAction::V0(transition) => transition.identity_id,
57        }
58    }
59
60    /// Asset Lock Outpoint
61    pub fn asset_lock_outpoint(&self) -> Bytes36 {
62        match self {
63            IdentityCreateTransitionAction::V0(action) => action.asset_lock_outpoint,
64        }
65    }
66
67    /// fee multiplier
68    pub fn user_fee_increase(&self) -> UserFeeIncrease {
69        match self {
70            IdentityCreateTransitionAction::V0(transition) => transition.user_fee_increase,
71        }
72    }
73}
74
75impl From<IdentityCreateTransitionAction> for PartialIdentity {
76    fn from(value: IdentityCreateTransitionAction) -> Self {
77        match value {
78            IdentityCreateTransitionAction::V0(v0) => v0.into(),
79        }
80    }
81}
82
83impl From<&IdentityCreateTransitionAction> for PartialIdentity {
84    fn from(value: &IdentityCreateTransitionAction) -> Self {
85        match value {
86            IdentityCreateTransitionAction::V0(v0) => v0.into(),
87        }
88    }
89}
90
91/// action
92pub trait IdentityFromIdentityCreateTransitionAction {
93    /// try from
94    fn try_from_identity_create_transition_action_returning_asset_lock_value(
95        value: IdentityCreateTransitionAction,
96        platform_version: &PlatformVersion,
97    ) -> Result<(Self, AssetLockValue), ProtocolError>
98    where
99        Self: Sized;
100    /// try from borrowed
101    fn try_from_borrowed_identity_create_transition_action(
102        value: &IdentityCreateTransitionAction,
103        platform_version: &PlatformVersion,
104    ) -> Result<Self, ProtocolError>
105    where
106        Self: Sized;
107}
108
109impl IdentityFromIdentityCreateTransitionAction for Identity {
110    fn try_from_identity_create_transition_action_returning_asset_lock_value(
111        value: IdentityCreateTransitionAction,
112        platform_version: &PlatformVersion,
113    ) -> Result<(Self, AssetLockValue), ProtocolError> {
114        match value {
115            IdentityCreateTransitionAction::V0(v0) => {
116                Identity::try_from_identity_create_transition_action_returning_asset_lock_value_v0(
117                    v0,
118                    platform_version,
119                )
120            }
121        }
122    }
123
124    fn try_from_borrowed_identity_create_transition_action(
125        value: &IdentityCreateTransitionAction,
126        platform_version: &PlatformVersion,
127    ) -> Result<Self, ProtocolError> {
128        match value {
129            IdentityCreateTransitionAction::V0(v0) => {
130                Identity::try_from_borrowed_identity_create_transition_action_v0(
131                    v0,
132                    platform_version,
133                )
134            }
135        }
136    }
137}
138
139#[cfg(test)]
140mod tests {
141    use super::*;
142    use crate::state_transition_action::identity::identity_create::v0::IdentityCreateTransitionActionV0;
143    use dpp::asset_lock::reduced_asset_lock_value::{AssetLockValue, AssetLockValueGettersV0};
144    use dpp::identity::accessors::IdentityGettersV0;
145    use dpp::identity::IdentityPublicKey;
146    use dpp::platform_value::{Bytes32, Bytes36};
147    use dpp::state_transition::signable_bytes_hasher::SignableBytesHasher;
148    use dpp::version::PlatformVersion;
149
150    fn make_asset_lock_value() -> AssetLockValue {
151        let platform_version = PlatformVersion::latest();
152        AssetLockValue::new(1000, vec![1, 2, 3], 500, vec![], platform_version)
153            .expect("expected asset lock value")
154    }
155
156    fn make_v0() -> IdentityCreateTransitionActionV0 {
157        let platform_version = PlatformVersion::latest();
158        let (key, _private) =
159            IdentityPublicKey::random_masternode_transfer_key(1, Some(42), platform_version)
160                .expect("expected a random key");
161        IdentityCreateTransitionActionV0 {
162            signable_bytes_hasher: SignableBytesHasher::PreHashed(Bytes32([0xCC; 32])),
163            public_keys: vec![key],
164            asset_lock_value_to_be_consumed: make_asset_lock_value(),
165            identity_id: Identifier::from([0xAA; 32]),
166            asset_lock_outpoint: Bytes36([0xDD; 36]),
167            user_fee_increase: 5,
168        }
169    }
170
171    #[test]
172    fn test_from_v0() {
173        let v0 = make_v0();
174        let action: IdentityCreateTransitionAction = v0.into();
175        assert!(matches!(action, IdentityCreateTransitionAction::V0(_)));
176    }
177
178    #[test]
179    fn test_public_keys() {
180        let action = IdentityCreateTransitionAction::V0(make_v0());
181        assert_eq!(action.public_keys().len(), 1);
182    }
183
184    #[test]
185    fn test_asset_lock_value_to_be_consumed() {
186        let action = IdentityCreateTransitionAction::V0(make_v0());
187        let alv = action.asset_lock_value_to_be_consumed();
188        assert_eq!(alv.remaining_credit_value(), 500);
189        assert_eq!(alv.initial_credit_value(), 1000);
190    }
191
192    #[test]
193    fn test_asset_lock_value_to_be_consumed_owned() {
194        let action = IdentityCreateTransitionAction::V0(make_v0());
195        let alv = action.asset_lock_value_to_be_consumed_owned();
196        assert_eq!(alv.remaining_credit_value(), 500);
197    }
198
199    #[test]
200    fn test_identity_id() {
201        let action = IdentityCreateTransitionAction::V0(make_v0());
202        assert_eq!(action.identity_id(), Identifier::from([0xAA; 32]));
203    }
204
205    #[test]
206    fn test_asset_lock_outpoint() {
207        let action = IdentityCreateTransitionAction::V0(make_v0());
208        assert_eq!(action.asset_lock_outpoint(), Bytes36([0xDD; 36]));
209    }
210
211    #[test]
212    fn test_user_fee_increase() {
213        let action = IdentityCreateTransitionAction::V0(make_v0());
214        assert_eq!(action.user_fee_increase(), 5);
215    }
216
217    #[test]
218    fn test_into_partial_identity_owned() {
219        let action = IdentityCreateTransitionAction::V0(make_v0());
220        let partial: PartialIdentity = action.into();
221        assert_eq!(partial.id, Identifier::from([0xAA; 32]));
222        assert_eq!(partial.balance, Some(500));
223        assert!(partial.revision.is_none());
224    }
225
226    #[test]
227    fn test_into_partial_identity_borrowed() {
228        let action = IdentityCreateTransitionAction::V0(make_v0());
229        let partial: PartialIdentity = (&action).into();
230        assert_eq!(partial.id, Identifier::from([0xAA; 32]));
231        assert_eq!(partial.balance, Some(500));
232    }
233
234    #[test]
235    fn test_try_from_identity_create_transition_action_returning_asset_lock_value() {
236        let platform_version = PlatformVersion::latest();
237        let action = IdentityCreateTransitionAction::V0(make_v0());
238        let (identity, alv) =
239            Identity::try_from_identity_create_transition_action_returning_asset_lock_value(
240                action,
241                platform_version,
242            )
243            .expect("expected identity");
244        assert_eq!(identity.id(), Identifier::from([0xAA; 32]));
245        assert_eq!(alv.remaining_credit_value(), 500);
246    }
247
248    #[test]
249    fn test_try_from_borrowed_identity_create_transition_action() {
250        let platform_version = PlatformVersion::latest();
251        let action = IdentityCreateTransitionAction::V0(make_v0());
252        let identity = Identity::try_from_borrowed_identity_create_transition_action(
253            &action,
254            platform_version,
255        )
256        .expect("expected identity");
257        assert_eq!(identity.id(), Identifier::from([0xAA; 32]));
258    }
259}
drive/state_transition_action/identity/identity_create/mod.rs

drive/state_transition_action/identity/identity_create/
mod.rs
