dpp/group/group_action/
mod.rs

1pub mod v0;
2
3use crate::data_contract::TokenContractPosition;
4use crate::group::action_event::GroupActionEvent;
5use crate::group::group_action::v0::GroupActionV0;
6#[cfg(feature = "json-conversion")]
7use crate::serialization::JsonConvertible;
8#[cfg(feature = "value-conversion")]
9use crate::serialization::ValueConvertible;
10use crate::ProtocolError;
11use bincode::{Decode, Encode};
12use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
13use platform_value::Identifier;
14#[cfg(feature = "serde-conversion")]
15use serde::{Deserialize, Serialize};
16
17#[cfg_attr(
18    all(feature = "json-conversion", feature = "serde-conversion"),
19    derive(JsonConvertible)
20)]
21#[derive(
22    Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize,
23)]
24#[cfg_attr(
25    feature = "serde-conversion",
26    derive(Serialize, Deserialize),
27    serde(tag = "$formatVersion")
28)]
29#[cfg_attr(feature = "value-conversion", derive(ValueConvertible))]
30#[platform_serialize(unversioned)] //versioned directly, no need to use platform_version
31pub enum GroupAction {
32    #[cfg_attr(feature = "serde-conversion", serde(rename = "0"))]
33    V0(GroupActionV0),
34}
35
36pub trait GroupActionAccessors {
37    fn contract_id(&self) -> Identifier;
38
39    fn proposer_id(&self) -> Identifier;
40    fn token_contract_position(&self) -> TokenContractPosition;
41    fn event(&self) -> &GroupActionEvent;
42}
43impl GroupActionAccessors for GroupAction {
44    fn contract_id(&self) -> Identifier {
45        match self {
46            GroupAction::V0(inner) => inner.contract_id(),
47        }
48    }
49
50    fn proposer_id(&self) -> Identifier {
51        match self {
52            GroupAction::V0(inner) => inner.proposer_id(),
53        }
54    }
55
56    fn token_contract_position(&self) -> TokenContractPosition {
57        match self {
58            GroupAction::V0(inner) => inner.token_contract_position(),
59        }
60    }
61
62    fn event(&self) -> &GroupActionEvent {
63        match self {
64            GroupAction::V0(inner) => inner.event(),
65        }
66    }
67}