drive/state_transition_action/identity/identity_create/v0/
mod.rs

1/// transformer
2pub mod transformer;
3
4use dpp::identifier::Identifier;
5use dpp::identity::{IdentityPublicKey, IdentityV0, PartialIdentity};
6
7use dpp::asset_lock::reduced_asset_lock_value::{AssetLockValue, AssetLockValueGettersV0};
8use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
9use dpp::identity::Identity;
10use dpp::platform_value::Bytes36;
11use dpp::prelude::UserFeeIncrease;
12use dpp::state_transition::signable_bytes_hasher::SignableBytesHasher;
13use dpp::version::PlatformVersion;
14use dpp::ProtocolError;
15
16/// action v0
17#[derive(Debug, Clone)]
18pub struct IdentityCreateTransitionActionV0 {
19    /// The state transition signable bytes hash
20    pub signable_bytes_hasher: SignableBytesHasher,
21    /// public keys
22    pub public_keys: Vec<IdentityPublicKey>,
23    /// the initial balance amount is equal to the remaining asset lock value
24    pub asset_lock_value_to_be_consumed: AssetLockValue,
25    /// identity id
26    pub identity_id: Identifier,
27    /// asset lock outpoint
28    pub asset_lock_outpoint: Bytes36,
29    /// fee multiplier
30    pub user_fee_increase: UserFeeIncrease,
31}
32
33impl From<IdentityCreateTransitionActionV0> for PartialIdentity {
34    fn from(value: IdentityCreateTransitionActionV0) -> Self {
35        let IdentityCreateTransitionActionV0 {
36            asset_lock_value_to_be_consumed,
37            identity_id,
38            ..
39        } = value;
40        PartialIdentity {
41            id: identity_id,
42            loaded_public_keys: Default::default(), //no need to load public keys
43            balance: Some(asset_lock_value_to_be_consumed.remaining_credit_value()),
44            revision: None,
45
46            not_found_public_keys: Default::default(),
47        }
48    }
49}
50
51impl From<&IdentityCreateTransitionActionV0> for PartialIdentity {
52    fn from(value: &IdentityCreateTransitionActionV0) -> Self {
53        let IdentityCreateTransitionActionV0 {
54            asset_lock_value_to_be_consumed,
55            identity_id,
56            ..
57        } = value;
58        PartialIdentity {
59            id: *identity_id,
60            loaded_public_keys: Default::default(), //no need to load public keys
61            balance: Some(asset_lock_value_to_be_consumed.remaining_credit_value()),
62            revision: None,
63
64            not_found_public_keys: Default::default(),
65        }
66    }
67}
68
69/// action v0
70pub trait IdentityFromIdentityCreateTransitionActionV0 {
71    /// try from
72    fn try_from_identity_create_transition_action_returning_asset_lock_value_v0(
73        value: IdentityCreateTransitionActionV0,
74        platform_version: &PlatformVersion,
75    ) -> Result<(Self, AssetLockValue), ProtocolError>
76    where
77        Self: Sized;
78    /// try from borrowed
79    fn try_from_borrowed_identity_create_transition_action_v0(
80        value: &IdentityCreateTransitionActionV0,
81        platform_version: &PlatformVersion,
82    ) -> Result<Self, ProtocolError>
83    where
84        Self: Sized;
85}
86
87impl IdentityFromIdentityCreateTransitionActionV0 for Identity {
88    fn try_from_identity_create_transition_action_returning_asset_lock_value_v0(
89        value: IdentityCreateTransitionActionV0,
90        platform_version: &PlatformVersion,
91    ) -> Result<(Self, AssetLockValue), ProtocolError> {
92        let IdentityCreateTransitionActionV0 {
93            asset_lock_value_to_be_consumed,
94            identity_id,
95            public_keys,
96            ..
97        } = value;
98        match platform_version
99            .dpp
100            .identity_versions
101            .identity_structure_version
102        {
103            0 => Ok((
104                IdentityV0 {
105                    id: identity_id,
106                    public_keys: public_keys.into_iter().map(|key| (key.id(), key)).collect(),
107                    balance: asset_lock_value_to_be_consumed.remaining_credit_value(),
108                    revision: 0,
109                }
110                .into(),
111                asset_lock_value_to_be_consumed,
112            )),
113            version => Err(ProtocolError::UnknownVersionMismatch {
114                method: "Identity::try_from_identity_create_transition_action_v0".to_string(),
115                known_versions: vec![0],
116                received: version,
117            }),
118        }
119    }
120    fn try_from_borrowed_identity_create_transition_action_v0(
121        value: &IdentityCreateTransitionActionV0,
122        platform_version: &PlatformVersion,
123    ) -> Result<Self, ProtocolError> {
124        let IdentityCreateTransitionActionV0 {
125            asset_lock_value_to_be_consumed,
126            identity_id,
127            public_keys,
128            ..
129        } = value;
130        match platform_version
131            .dpp
132            .identity_versions
133            .identity_structure_version
134        {
135            0 => Ok(IdentityV0 {
136                id: *identity_id,
137                public_keys: public_keys
138                    .iter()
139                    .map(|key| (key.id(), key.clone()))
140                    .collect(),
141                balance: asset_lock_value_to_be_consumed.remaining_credit_value(),
142                revision: 0,
143            }
144            .into()),
145            version => Err(ProtocolError::UnknownVersionMismatch {
146                method: "Identity::try_from_borrowed_identity_create_transition_action_v0"
147                    .to_string(),
148                known_versions: vec![0],
149                received: version,
150            }),
151        }
152    }
153}
drive/state_transition_action/identity/identity_create/v0/mod.rs

drive/state_transition_action/identity/identity_create/v0/
mod.rs
