fix(dpp): bind token config update action_id to payload value (v1)

packages/rs-dpp/src/data_contract/associated_token/token_configuration_item.rs

@@ -66,6 +66,62 @@ pub enum TokenConfigurationChangeItem {
     MainControlGroup(Option<GroupContractPosition>),
 }
 impl TokenConfigurationChangeItem {
+    pub fn payload_serialization(&self) -> Result<Option<Vec<u8>>, ProtocolError> {
+        Ok(match self {
+            TokenConfigurationChangeItem::TokenConfigurationNoChange => None,
+            TokenConfigurationChangeItem::Conventions(convention) => Some(
+                bincode::encode_to_vec(convention, bincode::config::standard())
+                    .map_err(|e| ProtocolError::EncodingError(e.to_string()))?,
+            ),
+            TokenConfigurationChangeItem::ConventionsControlGroup(a)
+            | TokenConfigurationChangeItem::ConventionsAdminGroup(a)
+            | TokenConfigurationChangeItem::MaxSupplyControlGroup(a)
+            | TokenConfigurationChangeItem::MaxSupplyAdminGroup(a)
+            | TokenConfigurationChangeItem::PerpetualDistributionControlGroup(a)
+            | TokenConfigurationChangeItem::PerpetualDistributionAdminGroup(a)
+            | TokenConfigurationChangeItem::NewTokensDestinationIdentityControlGroup(a)
+            | TokenConfigurationChangeItem::NewTokensDestinationIdentityAdminGroup(a)
+            | TokenConfigurationChangeItem::MintingAllowChoosingDestinationControlGroup(a)
+            | TokenConfigurationChangeItem::MintingAllowChoosingDestinationAdminGroup(a)
+            | TokenConfigurationChangeItem::ManualMinting(a)
+            | TokenConfigurationChangeItem::ManualMintingAdminGroup(a)
+            | TokenConfigurationChangeItem::ManualBurning(a)
+            | TokenConfigurationChangeItem::ManualBurningAdminGroup(a)
+            | TokenConfigurationChangeItem::Freeze(a)
+            | TokenConfigurationChangeItem::FreezeAdminGroup(a)
+            | TokenConfigurationChangeItem::Unfreeze(a)
+            | TokenConfigurationChangeItem::UnfreezeAdminGroup(a)
+            | TokenConfigurationChangeItem::DestroyFrozenFunds(a)
+            | TokenConfigurationChangeItem::DestroyFrozenFundsAdminGroup(a)
+            | TokenConfigurationChangeItem::EmergencyAction(a)
+            | TokenConfigurationChangeItem::EmergencyActionAdminGroup(a)
+            | TokenConfigurationChangeItem::MarketplaceTradeModeControlGroup(a)
+            | TokenConfigurationChangeItem::MarketplaceTradeModeAdminGroup(a) => Some(a.to_bytes()),
+            TokenConfigurationChangeItem::MaxSupply(max_supply) => {
+                max_supply.map(|amount| amount.to_be_bytes().to_vec())
+            }
+            TokenConfigurationChangeItem::PerpetualDistribution(distribution) => distribution
+                .as_ref()
+                .map(|dist| {
+                    bincode::encode_to_vec(dist, bincode::config::standard())
+                        .map_err(|e| ProtocolError::EncodingError(e.to_string()))
+                })
+                .transpose()?,
+            TokenConfigurationChangeItem::NewTokensDestinationIdentity(identity) => {
+                identity.map(|id| id.to_vec())
+            }
+            TokenConfigurationChangeItem::MintingAllowChoosingDestination(allow) => {
+                Some(vec![*allow as u8])
+            }
+            TokenConfigurationChangeItem::MarketplaceTradeMode(mode) => Some(
+                bincode::encode_to_vec(mode, bincode::config::standard())
+                    .map_err(|e| ProtocolError::EncodingError(e.to_string()))?,
+            ),
+            TokenConfigurationChangeItem::MainControlGroup(position) => {
+                position.map(|pos| pos.to_be_bytes().to_vec())
+            }
+        })
+    }
     pub fn u8_item_index(&self) -> u8 {
         match self {
             TokenConfigurationChangeItem::TokenConfigurationNoChange => 0,

packages/rs-dpp/src/data_contract/change_control_rules/authorized_action_takers.rs

@@ -2,6 +2,7 @@ use crate::data_contract::group::accessors::v0::GroupV0Getters;
 use crate::data_contract::group::{Group, GroupMemberPower};
 use crate::data_contract::GroupContractPosition;
 use crate::group::action_taker::{ActionGoal, ActionTaker};
+use crate::ProtocolError;
 use bincode::{Decode, Encode};
 use platform_value::Identifier;
 use serde::{Deserialize, Serialize};
@@ -33,6 +34,61 @@ impl fmt::Display for AuthorizedActionTakers {
 }
 
 impl AuthorizedActionTakers {
+    pub fn to_bytes(&self) -> Vec<u8> {
+        match self {
+            AuthorizedActionTakers::NoOne => vec![0],
+            AuthorizedActionTakers::ContractOwner => vec![1],
+            AuthorizedActionTakers::Identity(identifier) => {
+                let mut bytes = vec![2];
+                bytes.extend_from_slice(identifier.as_bytes());
+                bytes
+            }
+            AuthorizedActionTakers::MainGroup => vec![3],
+            AuthorizedActionTakers::Group(position) => {
+                let mut bytes = vec![4];
+                bytes.extend_from_slice(&position.to_be_bytes());
+                bytes
+            }
+        }
+    }
+
+    pub fn from_bytes(bytes: &[u8]) -> Result<Self, ProtocolError> {
+        let Some(&tag) = bytes.first() else {
+            return Err(ProtocolError::DecodingError(
+                "empty bytes for AuthorizedActionTakers".to_string(),
+            ));
+        };
+        match tag {
+            0 => Ok(AuthorizedActionTakers::NoOne),
+            1 => Ok(AuthorizedActionTakers::ContractOwner),
+            2 => {
+                if bytes.len() != 33 {
+                    return Err(ProtocolError::DecodingError(format!(
+                        "expected 33 bytes for AuthorizedActionTakers::Identity, got {}",
+                        bytes.len()
+                    )));
+                }
+                let identifier = Identifier::from_bytes(&bytes[1..])
+                    .map_err(|e| ProtocolError::DecodingError(e.to_string()))?;
+                Ok(AuthorizedActionTakers::Identity(identifier))
+            }
+            3 => Ok(AuthorizedActionTakers::MainGroup),
+            4 => {
+                if bytes.len() != 3 {
+                    return Err(ProtocolError::DecodingError(format!(
+                        "expected 3 bytes for AuthorizedActionTakers::Group, got {}",
+                        bytes.len()
+                    )));
+                }
+                let position = u16::from_be_bytes([bytes[1], bytes[2]]);
+                Ok(AuthorizedActionTakers::Group(position))
+            }
+            other => Err(ProtocolError::DecodingError(format!(
+                "unknown AuthorizedActionTakers tag: {}",
+                other
+            ))),
+        }
+    }
     pub fn allowed_for_action_taker(
         &self,
         contract_owner_id: &Identifier,

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/multi_party_action.rs

@@ -1,5 +1,11 @@
+use crate::ProtocolError;
 use platform_value::Identifier;
+use platform_version::version::PlatformVersion;
 
 pub trait AllowedAsMultiPartyAction {
-    fn calculate_action_id(&self, owner_id: Identifier) -> Identifier;
+    fn calculate_action_id(
+        &self,
+        owner_id: Identifier,
+        platform_version: &PlatformVersion,
+    ) -> Result<Identifier, ProtocolError>;
 }

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/v0/v0_methods.rs

@@ -1,4 +1,6 @@
 use platform_value::Identifier;
+use platform_version::version::PlatformVersion;
+use crate::ProtocolError;
 use crate::state_transition::batch_transition::batched_transition::multi_party_action::AllowedAsMultiPartyAction;
 use crate::state_transition::batch_transition::token_base_transition::token_base_transition_accessors::TokenBaseTransitionAccessors;
 use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition;
@@ -60,16 +62,20 @@ impl TokenBurnTransitionV0Methods for TokenBurnTransitionV0 {
 }
 
 impl AllowedAsMultiPartyAction for TokenBurnTransitionV0 {
-    fn calculate_action_id(&self, owner_id: Identifier) -> Identifier {
+    fn calculate_action_id(
+        &self,
+        owner_id: Identifier,
+        _platform_version: &PlatformVersion,
+    ) -> Result<Identifier, ProtocolError> {
         let TokenBurnTransitionV0 {
             base, burn_amount, ..
         } = self;
 
-        TokenBurnTransition::calculate_action_id_with_fields(
+        Ok(TokenBurnTransition::calculate_action_id_with_fields(
             base.token_id().as_bytes(),
             owner_id.as_bytes(),
             base.identity_contract_nonce(),
             *burn_amount,
-        )
+        ))
     }
 }

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/v0_methods.rs

@@ -1,6 +1,8 @@
 use platform_value::Identifier;
+use platform_version::version::PlatformVersion;
 use crate::balances::credits::TokenAmount;
 use crate::prelude::IdentityNonce;
+use crate::ProtocolError;
 use crate::state_transition::batch_transition::batched_transition::multi_party_action::AllowedAsMultiPartyAction;
 use crate::state_transition::batch_transition::token_base_transition::token_base_transition_accessors::TokenBaseTransitionAccessors;
 use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition;
@@ -61,9 +63,13 @@ impl TokenBurnTransitionV0Methods for TokenBurnTransition {
 }
 
 impl AllowedAsMultiPartyAction for TokenBurnTransition {
-    fn calculate_action_id(&self, owner_id: Identifier) -> Identifier {
+    fn calculate_action_id(
+        &self,
+        owner_id: Identifier,
+        platform_version: &PlatformVersion,
+    ) -> Result<Identifier, ProtocolError> {
         match self {
-            TokenBurnTransition::V0(v0) => v0.calculate_action_id(owner_id),
+            TokenBurnTransition::V0(v0) => v0.calculate_action_id(owner_id, platform_version),
         }
     }
 }

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_config_update_transition/v0/v0_methods.rs

@@ -1,5 +1,7 @@
 use platform_value::Identifier;
+use platform_version::version::PlatformVersion;
 use crate::data_contract::associated_token::token_configuration_item::TokenConfigurationChangeItem;
+use crate::ProtocolError;
 use crate::state_transition::batch_transition::batched_transition::multi_party_action::AllowedAsMultiPartyAction;
 use crate::state_transition::batch_transition::token_base_transition::token_base_transition_accessors::TokenBaseTransitionAccessors;
 use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition;
@@ -69,7 +71,12 @@ impl TokenConfigUpdateTransitionV0Methods for TokenConfigUpdateTransitionV0 {
 }
 
 impl AllowedAsMultiPartyAction for TokenConfigUpdateTransitionV0 {
-    fn calculate_action_id(&self, owner_id: Identifier) -> Identifier {
+    /// v0 action_id: uses only the u8 discriminant (kept for backward compat).
+    fn calculate_action_id(
+        &self,
+        owner_id: Identifier,
+        platform_version: &PlatformVersion,
+    ) -> Result<Identifier, ProtocolError> {
         let TokenConfigUpdateTransitionV0 {
             base,
             update_token_configuration_item,
@@ -80,7 +87,8 @@ impl AllowedAsMultiPartyAction for TokenConfigUpdateTransitionV0 {
             base.token_id().as_bytes(),
             owner_id.as_bytes(),
             base.identity_contract_nonce(),
-            update_token_configuration_item.u8_item_index(),
+            update_token_configuration_item,
+            platform_version,
         )
     }
 }