drive/state_transition_action/identity/identity_topup/
mod.rs

1/// transformer
2pub mod transformer;
3/// v0
4pub mod v0;
5
6use crate::state_transition_action::identity::identity_topup::v0::IdentityTopUpTransitionActionV0;
7use derive_more::From;
8use dpp::asset_lock::reduced_asset_lock_value::AssetLockValue;
9
10use dpp::platform_value::{Bytes36, Identifier};
11use dpp::prelude::UserFeeIncrease;
12
13/// action
14#[derive(Debug, Clone, From)]
15pub enum IdentityTopUpTransitionAction {
16    /// v0
17    V0(IdentityTopUpTransitionActionV0),
18}
19
20impl IdentityTopUpTransitionAction {
21    /// The balance being topped up
22    pub fn top_up_asset_lock_value(&self) -> &AssetLockValue {
23        match self {
24            IdentityTopUpTransitionAction::V0(transition) => &transition.top_up_asset_lock_value,
25        }
26    }
27
28    /// The balance being topped up
29    pub fn top_up_asset_lock_value_consume(self) -> AssetLockValue {
30        match self {
31            IdentityTopUpTransitionAction::V0(transition) => transition.top_up_asset_lock_value,
32        }
33    }
34
35    /// Identity Id
36    pub fn identity_id(&self) -> Identifier {
37        match self {
38            IdentityTopUpTransitionAction::V0(transition) => transition.identity_id,
39        }
40    }
41
42    /// Asset Lock Outpoint
43    pub fn asset_lock_outpoint(&self) -> Bytes36 {
44        match self {
45            IdentityTopUpTransitionAction::V0(action) => action.asset_lock_outpoint,
46        }
47    }
48
49    /// fee multiplier
50    pub fn user_fee_increase(&self) -> UserFeeIncrease {
51        match self {
52            IdentityTopUpTransitionAction::V0(transition) => transition.user_fee_increase,
53        }
54    }
55}
56
57#[cfg(test)]
58mod tests {
59    use super::*;
60    use crate::state_transition_action::identity::identity_topup::v0::IdentityTopUpTransitionActionV0;
61    use dpp::asset_lock::reduced_asset_lock_value::{AssetLockValue, AssetLockValueGettersV0};
62    use dpp::platform_value::{Bytes32, Bytes36};
63    use dpp::state_transition::signable_bytes_hasher::SignableBytesHasher;
64    use dpp::version::PlatformVersion;
65
66    fn make_asset_lock_value() -> AssetLockValue {
67        let platform_version = PlatformVersion::latest();
68        AssetLockValue::new(2000, vec![4, 5, 6], 1500, vec![], platform_version)
69            .expect("expected asset lock value")
70    }
71
72    fn make_v0() -> IdentityTopUpTransitionActionV0 {
73        IdentityTopUpTransitionActionV0 {
74            signable_bytes_hasher: SignableBytesHasher::PreHashed(Bytes32([0xCC; 32])),
75            top_up_asset_lock_value: make_asset_lock_value(),
76            identity_id: Identifier::from([0xAA; 32]),
77            asset_lock_outpoint: Bytes36([0xDD; 36]),
78            user_fee_increase: 4,
79        }
80    }
81
82    #[test]
83    fn test_from_v0() {
84        let v0 = make_v0();
85        let action: IdentityTopUpTransitionAction = v0.into();
86        assert!(matches!(action, IdentityTopUpTransitionAction::V0(_)));
87    }
88
89    #[test]
90    fn test_top_up_asset_lock_value() {
91        let action = IdentityTopUpTransitionAction::V0(make_v0());
92        let alv = action.top_up_asset_lock_value();
93        assert_eq!(alv.remaining_credit_value(), 1500);
94        assert_eq!(alv.initial_credit_value(), 2000);
95    }
96
97    #[test]
98    fn test_top_up_asset_lock_value_consume() {
99        let action = IdentityTopUpTransitionAction::V0(make_v0());
100        let alv = action.top_up_asset_lock_value_consume();
101        assert_eq!(alv.remaining_credit_value(), 1500);
102    }
103
104    #[test]
105    fn test_identity_id() {
106        let action = IdentityTopUpTransitionAction::V0(make_v0());
107        assert_eq!(action.identity_id(), Identifier::from([0xAA; 32]));
108    }
109
110    #[test]
111    fn test_asset_lock_outpoint() {
112        let action = IdentityTopUpTransitionAction::V0(make_v0());
113        assert_eq!(action.asset_lock_outpoint(), Bytes36([0xDD; 36]));
114    }
115
116    #[test]
117    fn test_user_fee_increase() {
118        let action = IdentityTopUpTransitionAction::V0(make_v0());
119        assert_eq!(action.user_fee_increase(), 4);
120    }
121}