dpp/data_contract/associated_token/
token_configuration_item.rs

1use crate::balances::credits::TokenAmount;
2use crate::data_contract::associated_token::token_configuration_convention::TokenConfigurationConvention;
3use crate::data_contract::associated_token::token_marketplace_rules::v0::TokenTradeMode;
4use crate::data_contract::associated_token::token_perpetual_distribution::TokenPerpetualDistribution;
5use crate::data_contract::change_control_rules::authorized_action_takers::AuthorizedActionTakers;
6use crate::data_contract::GroupContractPosition;
7use crate::ProtocolError;
8use bincode::Encode;
9use platform_serialization::de::Decode;
10use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
11use platform_value::Identifier;
12#[cfg(feature = "serde-conversion")]
13use serde::{Deserialize, Serialize};
14use std::fmt;
15
16#[derive(
17    Debug,
18    Clone,
19    Default,
20    PartialOrd,
21    Encode,
22    Decode,
23    PlatformSerialize,
24    PlatformDeserialize,
25    PartialEq,
26    Eq,
27)]
28#[cfg_attr(
29    feature = "serde-conversion",
30    derive(Serialize, Deserialize),
31    serde(rename_all = "camelCase")
32)]
33pub enum TokenConfigurationChangeItem {
34    #[default]
35    TokenConfigurationNoChange,
36    Conventions(TokenConfigurationConvention),
37    ConventionsControlGroup(AuthorizedActionTakers),
38    ConventionsAdminGroup(AuthorizedActionTakers),
39    MaxSupply(Option<TokenAmount>),
40    MaxSupplyControlGroup(AuthorizedActionTakers),
41    MaxSupplyAdminGroup(AuthorizedActionTakers),
42    PerpetualDistribution(Option<TokenPerpetualDistribution>),
43    PerpetualDistributionControlGroup(AuthorizedActionTakers),
44    PerpetualDistributionAdminGroup(AuthorizedActionTakers),
45    NewTokensDestinationIdentity(Option<Identifier>),
46    NewTokensDestinationIdentityControlGroup(AuthorizedActionTakers),
47    NewTokensDestinationIdentityAdminGroup(AuthorizedActionTakers),
48    MintingAllowChoosingDestination(bool),
49    MintingAllowChoosingDestinationControlGroup(AuthorizedActionTakers),
50    MintingAllowChoosingDestinationAdminGroup(AuthorizedActionTakers),
51    ManualMinting(AuthorizedActionTakers),
52    ManualMintingAdminGroup(AuthorizedActionTakers),
53    ManualBurning(AuthorizedActionTakers),
54    ManualBurningAdminGroup(AuthorizedActionTakers),
55    Freeze(AuthorizedActionTakers),
56    FreezeAdminGroup(AuthorizedActionTakers),
57    Unfreeze(AuthorizedActionTakers),
58    UnfreezeAdminGroup(AuthorizedActionTakers),
59    DestroyFrozenFunds(AuthorizedActionTakers),
60    DestroyFrozenFundsAdminGroup(AuthorizedActionTakers),
61    EmergencyAction(AuthorizedActionTakers),
62    EmergencyActionAdminGroup(AuthorizedActionTakers),
63    MarketplaceTradeMode(TokenTradeMode),
64    MarketplaceTradeModeControlGroup(AuthorizedActionTakers),
65    MarketplaceTradeModeAdminGroup(AuthorizedActionTakers),
66    MainControlGroup(Option<GroupContractPosition>),
67}
68impl TokenConfigurationChangeItem {
69    pub fn payload_serialization(&self) -> Result<Option<Vec<u8>>, ProtocolError> {
70        Ok(match self {
71            TokenConfigurationChangeItem::TokenConfigurationNoChange => None,
72            TokenConfigurationChangeItem::Conventions(convention) => Some(
73                bincode::encode_to_vec(convention, bincode::config::standard())
74                    .map_err(|e| ProtocolError::EncodingError(e.to_string()))?,
75            ),
76            TokenConfigurationChangeItem::ConventionsControlGroup(a)
77            | TokenConfigurationChangeItem::ConventionsAdminGroup(a)
78            | TokenConfigurationChangeItem::MaxSupplyControlGroup(a)
79            | TokenConfigurationChangeItem::MaxSupplyAdminGroup(a)
80            | TokenConfigurationChangeItem::PerpetualDistributionControlGroup(a)
81            | TokenConfigurationChangeItem::PerpetualDistributionAdminGroup(a)
82            | TokenConfigurationChangeItem::NewTokensDestinationIdentityControlGroup(a)
83            | TokenConfigurationChangeItem::NewTokensDestinationIdentityAdminGroup(a)
84            | TokenConfigurationChangeItem::MintingAllowChoosingDestinationControlGroup(a)
85            | TokenConfigurationChangeItem::MintingAllowChoosingDestinationAdminGroup(a)
86            | TokenConfigurationChangeItem::ManualMinting(a)
87            | TokenConfigurationChangeItem::ManualMintingAdminGroup(a)
88            | TokenConfigurationChangeItem::ManualBurning(a)
89            | TokenConfigurationChangeItem::ManualBurningAdminGroup(a)
90            | TokenConfigurationChangeItem::Freeze(a)
91            | TokenConfigurationChangeItem::FreezeAdminGroup(a)
92            | TokenConfigurationChangeItem::Unfreeze(a)
93            | TokenConfigurationChangeItem::UnfreezeAdminGroup(a)
94            | TokenConfigurationChangeItem::DestroyFrozenFunds(a)
95            | TokenConfigurationChangeItem::DestroyFrozenFundsAdminGroup(a)
96            | TokenConfigurationChangeItem::EmergencyAction(a)
97            | TokenConfigurationChangeItem::EmergencyActionAdminGroup(a)
98            | TokenConfigurationChangeItem::MarketplaceTradeModeControlGroup(a)
99            | TokenConfigurationChangeItem::MarketplaceTradeModeAdminGroup(a) => Some(a.to_bytes()),
100            TokenConfigurationChangeItem::MaxSupply(max_supply) => {
101                max_supply.map(|amount| amount.to_be_bytes().to_vec())
102            }
103            TokenConfigurationChangeItem::PerpetualDistribution(distribution) => distribution
104                .as_ref()
105                .map(|dist| {
106                    bincode::encode_to_vec(dist, bincode::config::standard())
107                        .map_err(|e| ProtocolError::EncodingError(e.to_string()))
108                })
109                .transpose()?,
110            TokenConfigurationChangeItem::NewTokensDestinationIdentity(identity) => {
111                identity.map(|id| id.to_vec())
112            }
113            TokenConfigurationChangeItem::MintingAllowChoosingDestination(allow) => {
114                Some(vec![*allow as u8])
115            }
116            TokenConfigurationChangeItem::MarketplaceTradeMode(mode) => Some(
117                bincode::encode_to_vec(mode, bincode::config::standard())
118                    .map_err(|e| ProtocolError::EncodingError(e.to_string()))?,
119            ),
120            TokenConfigurationChangeItem::MainControlGroup(position) => {
121                position.map(|pos| pos.to_be_bytes().to_vec())
122            }
123        })
124    }
125    pub fn u8_item_index(&self) -> u8 {
126        match self {
127            TokenConfigurationChangeItem::TokenConfigurationNoChange => 0,
128            TokenConfigurationChangeItem::Conventions(_) => 1,
129            TokenConfigurationChangeItem::ConventionsControlGroup(_) => 2,
130            TokenConfigurationChangeItem::ConventionsAdminGroup(_) => 3,
131            TokenConfigurationChangeItem::MaxSupply(_) => 4,
132            TokenConfigurationChangeItem::MaxSupplyControlGroup(_) => 5,
133            TokenConfigurationChangeItem::MaxSupplyAdminGroup(_) => 6,
134            TokenConfigurationChangeItem::PerpetualDistribution(_) => 7,
135            TokenConfigurationChangeItem::PerpetualDistributionControlGroup(_) => 8,
136            TokenConfigurationChangeItem::PerpetualDistributionAdminGroup(_) => 9,
137            TokenConfigurationChangeItem::NewTokensDestinationIdentity(_) => 10,
138            TokenConfigurationChangeItem::NewTokensDestinationIdentityControlGroup(_) => 11,
139            TokenConfigurationChangeItem::NewTokensDestinationIdentityAdminGroup(_) => 12,
140            TokenConfigurationChangeItem::MintingAllowChoosingDestination(_) => 13,
141            TokenConfigurationChangeItem::MintingAllowChoosingDestinationControlGroup(_) => 14,
142            TokenConfigurationChangeItem::MintingAllowChoosingDestinationAdminGroup(_) => 15,
143            TokenConfigurationChangeItem::ManualMinting(_) => 16,
144            TokenConfigurationChangeItem::ManualMintingAdminGroup(_) => 17,
145            TokenConfigurationChangeItem::ManualBurning(_) => 18,
146            TokenConfigurationChangeItem::ManualBurningAdminGroup(_) => 19,
147            TokenConfigurationChangeItem::Freeze(_) => 20,
148            TokenConfigurationChangeItem::FreezeAdminGroup(_) => 21,
149            TokenConfigurationChangeItem::Unfreeze(_) => 22,
150            TokenConfigurationChangeItem::UnfreezeAdminGroup(_) => 23,
151            TokenConfigurationChangeItem::DestroyFrozenFunds(_) => 24,
152            TokenConfigurationChangeItem::DestroyFrozenFundsAdminGroup(_) => 25,
153            TokenConfigurationChangeItem::EmergencyAction(_) => 26,
154            TokenConfigurationChangeItem::EmergencyActionAdminGroup(_) => 27,
155            TokenConfigurationChangeItem::MarketplaceTradeMode(_) => 28,
156            TokenConfigurationChangeItem::MarketplaceTradeModeControlGroup(_) => 29,
157            TokenConfigurationChangeItem::MarketplaceTradeModeAdminGroup(_) => 30,
158            TokenConfigurationChangeItem::MainControlGroup(_) => 31,
159        }
160    }
161}
162
163impl fmt::Display for TokenConfigurationChangeItem {
164    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
165        match self {
166            TokenConfigurationChangeItem::TokenConfigurationNoChange => {
167                write!(f, "No Change in Token Configuration")
168            }
169            TokenConfigurationChangeItem::Conventions(convention) => {
170                write!(f, "Conventions: {}", convention)
171            }
172            TokenConfigurationChangeItem::ConventionsControlGroup(control_group) => {
173                write!(f, "Conventions Control Group: {}", control_group)
174            }
175            TokenConfigurationChangeItem::ConventionsAdminGroup(admin_group) => {
176                write!(f, "Conventions Admin Group: {}", admin_group)
177            }
178            TokenConfigurationChangeItem::MaxSupply(max_supply) => match max_supply {
179                Some(amount) => write!(f, "Max Supply: {}", amount),
180                None => write!(f, "Max Supply: No Limit"),
181            },
182            TokenConfigurationChangeItem::MaxSupplyControlGroup(control_group) => {
183                write!(f, "Max Supply Control Group: {}", control_group)
184            }
185            TokenConfigurationChangeItem::MaxSupplyAdminGroup(admin_group) => {
186                write!(f, "Max Supply Admin Group: {}", admin_group)
187            }
188            TokenConfigurationChangeItem::PerpetualDistribution(distribution) => match distribution
189            {
190                Some(dist) => write!(f, "Perpetual Distribution: {}", dist),
191                None => write!(f, "Perpetual Distribution: None"),
192            },
193            TokenConfigurationChangeItem::PerpetualDistributionControlGroup(control_group) => {
194                write!(f, "Perpetual Distribution Control Group: {}", control_group)
195            }
196            TokenConfigurationChangeItem::PerpetualDistributionAdminGroup(admin_group) => {
197                write!(f, "Perpetual Distribution Admin Group: {}", admin_group)
198            }
199            TokenConfigurationChangeItem::NewTokensDestinationIdentity(identity) => {
200                match identity {
201                    Some(id) => write!(f, "New Tokens Destination Identity: {}", id),
202                    None => write!(f, "New Tokens Destination Identity: None"),
203                }
204            }
205            TokenConfigurationChangeItem::NewTokensDestinationIdentityControlGroup(
206                control_group,
207            ) => {
208                write!(
209                    f,
210                    "New Tokens Destination Identity Control Group: {}",
211                    control_group
212                )
213            }
214            TokenConfigurationChangeItem::NewTokensDestinationIdentityAdminGroup(admin_group) => {
215                write!(
216                    f,
217                    "New Tokens Destination Identity Admin Group: {}",
218                    admin_group
219                )
220            }
221            TokenConfigurationChangeItem::MintingAllowChoosingDestination(allow) => {
222                write!(f, "Minting Allow Choosing Destination: {}", allow)
223            }
224            TokenConfigurationChangeItem::MintingAllowChoosingDestinationControlGroup(
225                control_group,
226            ) => {
227                write!(
228                    f,
229                    "Minting Allow Choosing Destination Control Group: {}",
230                    control_group
231                )
232            }
233            TokenConfigurationChangeItem::MintingAllowChoosingDestinationAdminGroup(
234                admin_group,
235            ) => {
236                write!(
237                    f,
238                    "Minting Allow Choosing Destination Admin Group: {}",
239                    admin_group
240                )
241            }
242            TokenConfigurationChangeItem::ManualMinting(control_group) => {
243                write!(f, "Manual Minting: {}", control_group)
244            }
245            TokenConfigurationChangeItem::ManualMintingAdminGroup(admin_group) => {
246                write!(f, "Manual Minting Admin Group: {}", admin_group)
247            }
248            TokenConfigurationChangeItem::ManualBurning(control_group) => {
249                write!(f, "Manual Burning: {}", control_group)
250            }
251            TokenConfigurationChangeItem::ManualBurningAdminGroup(admin_group) => {
252                write!(f, "Manual Burning Admin Group: {}", admin_group)
253            }
254            TokenConfigurationChangeItem::Freeze(control_group) => {
255                write!(f, "Freeze: {}", control_group)
256            }
257            TokenConfigurationChangeItem::FreezeAdminGroup(admin_group) => {
258                write!(f, "Freeze Admin Group: {}", admin_group)
259            }
260            TokenConfigurationChangeItem::Unfreeze(control_group) => {
261                write!(f, "Unfreeze: {}", control_group)
262            }
263            TokenConfigurationChangeItem::UnfreezeAdminGroup(admin_group) => {
264                write!(f, "Unfreeze Admin Group: {}", admin_group)
265            }
266            TokenConfigurationChangeItem::DestroyFrozenFunds(control_group) => {
267                write!(f, "Destroy Frozen Funds: {}", control_group)
268            }
269            TokenConfigurationChangeItem::DestroyFrozenFundsAdminGroup(admin_group) => {
270                write!(f, "Destroy Frozen Funds Admin Group: {}", admin_group)
271            }
272            TokenConfigurationChangeItem::EmergencyAction(control_group) => {
273                write!(f, "Emergency Action: {}", control_group)
274            }
275            TokenConfigurationChangeItem::EmergencyActionAdminGroup(admin_group) => {
276                write!(f, "Emergency Action Admin Group: {}", admin_group)
277            }
278            TokenConfigurationChangeItem::MainControlGroup(position) => match position {
279                Some(pos) => write!(f, "Main Control Group: {}", pos),
280                None => write!(f, "Main Control Group: None"),
281            },
282            TokenConfigurationChangeItem::MarketplaceTradeMode(mode) => {
283                write!(f, "Marketplace Trade Mode: {:?}", mode)
284            }
285            TokenConfigurationChangeItem::MarketplaceTradeModeControlGroup(control_group) => {
286                write!(f, "Marketplace Trade Mode Control Group: {}", control_group)
287            }
288            TokenConfigurationChangeItem::MarketplaceTradeModeAdminGroup(admin_group) => {
289                write!(f, "Marketplace Trade Mode Admin Group: {}", admin_group)
290            }
291        }
292    }
293}
294
295#[cfg(test)]
296mod tests {
297    use super::*;
298    use std::collections::BTreeSet;
299
300    /// Helper: build one instance of every variant using default inner values.
301    fn all_variants() -> Vec<TokenConfigurationChangeItem> {
302        let aat = AuthorizedActionTakers::NoOne;
303        vec![
304            TokenConfigurationChangeItem::TokenConfigurationNoChange,
305            TokenConfigurationChangeItem::Conventions(
306                TokenConfigurationConvention::V0(
307                    crate::data_contract::associated_token::token_configuration_convention::v0::TokenConfigurationConventionV0::default(),
308                ),
309            ),
310            TokenConfigurationChangeItem::ConventionsControlGroup(aat.clone()),
311            TokenConfigurationChangeItem::ConventionsAdminGroup(aat.clone()),
312            TokenConfigurationChangeItem::MaxSupply(None),
313            TokenConfigurationChangeItem::MaxSupplyControlGroup(aat.clone()),
314            TokenConfigurationChangeItem::MaxSupplyAdminGroup(aat.clone()),
315            TokenConfigurationChangeItem::PerpetualDistribution(None),
316            TokenConfigurationChangeItem::PerpetualDistributionControlGroup(aat.clone()),
317            TokenConfigurationChangeItem::PerpetualDistributionAdminGroup(aat.clone()),
318            TokenConfigurationChangeItem::NewTokensDestinationIdentity(None),
319            TokenConfigurationChangeItem::NewTokensDestinationIdentityControlGroup(aat.clone()),
320            TokenConfigurationChangeItem::NewTokensDestinationIdentityAdminGroup(aat.clone()),
321            TokenConfigurationChangeItem::MintingAllowChoosingDestination(false),
322            TokenConfigurationChangeItem::MintingAllowChoosingDestinationControlGroup(aat.clone()),
323            TokenConfigurationChangeItem::MintingAllowChoosingDestinationAdminGroup(aat.clone()),
324            TokenConfigurationChangeItem::ManualMinting(aat.clone()),
325            TokenConfigurationChangeItem::ManualMintingAdminGroup(aat.clone()),
326            TokenConfigurationChangeItem::ManualBurning(aat.clone()),
327            TokenConfigurationChangeItem::ManualBurningAdminGroup(aat.clone()),
328            TokenConfigurationChangeItem::Freeze(aat.clone()),
329            TokenConfigurationChangeItem::FreezeAdminGroup(aat.clone()),
330            TokenConfigurationChangeItem::Unfreeze(aat.clone()),
331            TokenConfigurationChangeItem::UnfreezeAdminGroup(aat.clone()),
332            TokenConfigurationChangeItem::DestroyFrozenFunds(aat.clone()),
333            TokenConfigurationChangeItem::DestroyFrozenFundsAdminGroup(aat.clone()),
334            TokenConfigurationChangeItem::EmergencyAction(aat.clone()),
335            TokenConfigurationChangeItem::EmergencyActionAdminGroup(aat.clone()),
336            TokenConfigurationChangeItem::MarketplaceTradeMode(TokenTradeMode::default()),
337            TokenConfigurationChangeItem::MarketplaceTradeModeControlGroup(aat.clone()),
338            TokenConfigurationChangeItem::MarketplaceTradeModeAdminGroup(aat.clone()),
339            TokenConfigurationChangeItem::MainControlGroup(None),
340        ]
341    }
342
343    // ---- u8_item_index returns unique values 0..=31 ----
344
345    #[test]
346    fn u8_item_index_values_are_unique() {
347        let variants = all_variants();
348        let indices: Vec<u8> = variants.iter().map(|v| v.u8_item_index()).collect();
349        let unique: BTreeSet<u8> = indices.iter().cloned().collect();
350        assert_eq!(
351            indices.len(),
352            unique.len(),
353            "Duplicate u8_item_index values found: {:?}",
354            indices
355        );
356    }
357
358    #[test]
359    fn u8_item_index_covers_0_through_31() {
360        let variants = all_variants();
361        let indices: BTreeSet<u8> = variants.iter().map(|v| v.u8_item_index()).collect();
362        for i in 0u8..=31 {
363            assert!(indices.contains(&i), "Missing u8_item_index value: {}", i);
364        }
365    }
366
367    #[test]
368    fn u8_item_index_all_within_range() {
369        let variants = all_variants();
370        for v in &variants {
371            let idx = v.u8_item_index();
372            assert!(idx <= 31, "Index {} exceeds expected max of 31", idx);
373        }
374    }
375
376    #[test]
377    fn u8_item_index_specific_known_values() {
378        assert_eq!(
379            TokenConfigurationChangeItem::TokenConfigurationNoChange.u8_item_index(),
380            0
381        );
382        assert_eq!(
383            TokenConfigurationChangeItem::MaxSupply(Some(100)).u8_item_index(),
384            4
385        );
386        assert_eq!(
387            TokenConfigurationChangeItem::ManualMinting(AuthorizedActionTakers::NoOne)
388                .u8_item_index(),
389            16
390        );
391        assert_eq!(
392            TokenConfigurationChangeItem::MainControlGroup(Some(5)).u8_item_index(),
393            31
394        );
395    }
396
397    #[test]
398    fn u8_item_index_variant_count() {
399        // We expect exactly 32 variants (indices 0..=31)
400        let variants = all_variants();
401        assert_eq!(variants.len(), 32);
402    }
403}
dpp/data_contract/associated_token/token_configuration_item.rs

dpp/data_contract/associated_token/
token_configuration_item.rs
