Add transaction capabilities

sdk/src/client/api/block_builder/input_selection/mod.rs

@@ -499,6 +499,7 @@ impl InputSelection {
                             foundry_output,
                             input_native_tokens_builder.deref(),
                             output_native_tokens_builder.deref(),
+                            Default::default(),
                         ) {
                             log::debug!("validate_transitions error {err:?}");
                             return Err(Error::UnfulfillableRequirement(Requirement::Foundry(

sdk/src/types/block/error.rs

@@ -30,8 +30,10 @@ use crate::types::block::{
 pub enum Error {
     ManaAllotmentsNotUniqueSorted,
     ConsumedAmountOverflow,
+    ConsumedManaOverflow,
     ConsumedNativeTokensAmountOverflow,
     CreatedAmountOverflow,
+    CreatedManaOverflow,
     CreatedNativeTokensAmountOverflow,
     Crypto(CryptoError),
     DuplicateBicAccountId(AccountId),
@@ -182,8 +184,10 @@ impl fmt::Display for Error {
         match self {
             Self::ManaAllotmentsNotUniqueSorted => write!(f, "mana allotments are not unique and/or sorted"),
             Self::ConsumedAmountOverflow => write!(f, "consumed amount overflow"),
+            Self::ConsumedManaOverflow => write!(f, "consumed mana overflow"),
             Self::ConsumedNativeTokensAmountOverflow => write!(f, "consumed native tokens amount overflow"),
             Self::CreatedAmountOverflow => write!(f, "created amount overflow"),
+            Self::CreatedManaOverflow => write!(f, "created mana overflow"),
             Self::CreatedNativeTokensAmountOverflow => write!(f, "created native tokens amount overflow"),
             Self::Crypto(e) => write!(f, "cryptographic error: {e}"),
             Self::DuplicateBicAccountId(account_id) => write!(f, "duplicate BIC account id: {account_id}"),

sdk/src/types/block/output/account.rs

@@ -25,6 +25,7 @@ use crate::types::{
             NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError,
             StateTransitionVerifier,
         },
+        payload::transaction::TransactionCapabilityFlag,
         protocol::ProtocolParameters,
         semantic::{TransactionFailureReason, ValidationContext},
         unlock::Unlock,
@@ -646,7 +647,15 @@ impl StateTransitionVerifier for AccountOutput {
         )
     }
 
-    fn destruction(_current_state: &Self, _context: &ValidationContext<'_>) -> Result<(), StateTransitionError> {
+    fn destruction(_current_state: &Self, context: &ValidationContext<'_>) -> Result<(), StateTransitionError> {
+        if context
+            .essence
+            .capabilities()
+            .has_capability(TransactionCapabilityFlag::DestroyAccountOutputs)
+        {
+            // TODO: is this correct?
+            return Err(StateTransitionError::UnsupportedStateTransition);
+        }
         Ok(())
     }
 }

sdk/src/types/block/output/delegation.rs

@@ -359,6 +359,7 @@ impl DelegationOutput {
 
     // Transition, just without full ValidationContext.
     pub(crate) fn transition_inner(current_state: &Self, next_state: &Self) -> Result<(), StateTransitionError> {
+        #[allow(clippy::nonminimal_bool)]
         if !(current_state.delegation_id.is_null() && !next_state.delegation_id().is_null()) {
             return Err(StateTransitionError::NonDelayedClaimingTransition);
         }

sdk/src/types/block/output/foundry.rs

@@ -25,6 +25,7 @@ use crate::types::{
             NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError,
             StateTransitionVerifier, TokenId, TokenScheme,
         },
+        payload::transaction::{TransactionCapabilities, TransactionCapabilityFlag},
         protocol::ProtocolParameters,
         semantic::{TransactionFailureReason, ValidationContext},
         unlock::Unlock,
@@ -457,6 +458,7 @@ impl FoundryOutput {
         next_state: &Self,
         input_native_tokens: &BTreeMap<TokenId, U256>,
         output_native_tokens: &BTreeMap<TokenId, U256>,
+        capabilities: TransactionCapabilities,
     ) -> Result<(), StateTransitionError> {
         if current_state.account_address() != next_state.account_address()
             || current_state.serial_number != next_state.serial_number
@@ -510,6 +512,11 @@ impl FoundryOutput {
             Ordering::Greater => {
                 // Melt / Burn
 
+                if capabilities.has_capability(TransactionCapabilityFlag::BurnNativeTokens) {
+                    // TODO: is this correct?
+                    return Err(StateTransitionError::UnsupportedStateTransition);
+                }
+
                 if current_token_scheme.melted_tokens() != next_token_scheme.melted_tokens()
                     && current_token_scheme.minted_tokens() != next_token_scheme.minted_tokens()
                 {
@@ -574,10 +581,20 @@ impl StateTransitionVerifier for FoundryOutput {
             next_state,
             &context.input_native_tokens,
             &context.output_native_tokens,
+            context.essence.capabilities(),
         )
     }
 
     fn destruction(current_state: &Self, context: &ValidationContext<'_>) -> Result<(), StateTransitionError> {
+        if context
+            .essence
+            .capabilities()
+            .has_capability(TransactionCapabilityFlag::DestroyFoundryOutputs)
+        {
+            // TODO: is this correct?
+            return Err(StateTransitionError::UnsupportedStateTransition);
+        }
+
         let token_id = current_state.token_id();
         let input_tokens = context.input_native_tokens.get(&token_id).copied().unwrap_or_default();
         let TokenScheme::Simple(ref current_token_scheme) = current_state.token_scheme;

sdk/src/types/block/output/nft.rs

@@ -22,6 +22,7 @@ use crate::types::{
             NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError,
             StateTransitionVerifier,
         },
+        payload::transaction::TransactionCapabilityFlag,
         protocol::ProtocolParameters,
         semantic::{TransactionFailureReason, ValidationContext},
         unlock::Unlock,
@@ -456,7 +457,15 @@ impl StateTransitionVerifier for NftOutput {
         Self::transition_inner(current_state, next_state)
     }
 
-    fn destruction(_current_state: &Self, _context: &ValidationContext<'_>) -> Result<(), StateTransitionError> {
+    fn destruction(_current_state: &Self, context: &ValidationContext<'_>) -> Result<(), StateTransitionError> {
+        if context
+            .essence
+            .capabilities()
+            .has_capability(TransactionCapabilityFlag::DestroyNftOutputs)
+        {
+            // TODO: is this correct?
+            return Err(StateTransitionError::UnsupportedStateTransition);
+        }
         Ok(())
     }
 }

sdk/src/types/block/payload/transaction/essence/mod.rs

@@ -8,7 +8,9 @@ use derive_more::From;
 use packable::PackableExt;
 
 pub(crate) use self::regular::{ContextInputCount, InputCount, OutputCount};
-pub use self::regular::{RegularTransactionEssence, RegularTransactionEssenceBuilder};
+pub use self::regular::{
+    RegularTransactionEssence, RegularTransactionEssenceBuilder, TransactionCapabilities, TransactionCapabilityFlag,
+};
 use crate::types::block::Error;
 
 /// A generic essence that can represent different types defining transaction essences.

sdk/src/types/block/payload/transaction/essence/regular.rs

@@ -3,6 +3,7 @@
 
 use alloc::{collections::BTreeSet, vec::Vec};
 
+use derive_more::Deref;
 use hashbrown::HashSet;
 use packable::{bounded::BoundedU16, prefix::BoxedSlicePrefix, Packable};
 
@@ -30,6 +31,7 @@ pub struct RegularTransactionEssenceBuilder {
     inputs_commitment: InputsCommitment,
     outputs: Vec<Output>,
     allotments: BTreeSet<ManaAllotment>,
+    capabilities: TransactionCapabilities,
     payload: OptionalPayload,
     creation_slot: Option<SlotIndex>,
 }
@@ -44,6 +46,7 @@ impl RegularTransactionEssenceBuilder {
             inputs_commitment,
             outputs: Vec::new(),
             allotments: BTreeSet::new(),
+            capabilities: Default::default(),
             payload: OptionalPayload::default(),
             creation_slot: None,
         }
@@ -109,6 +112,11 @@ impl RegularTransactionEssenceBuilder {
         self
     }
 
+    pub fn with_capabilities(mut self, capabilities: impl Into<TransactionCapabilities>) -> Self {
+        self.capabilities = capabilities.into();
+        self
+    }
+
     /// Finishes a [`RegularTransactionEssenceBuilder`] into a [`RegularTransactionEssence`].
     pub fn finish_with_params<'a>(
         self,
@@ -182,6 +190,7 @@ impl RegularTransactionEssenceBuilder {
             inputs_commitment: self.inputs_commitment,
             outputs,
             allotments,
+            capabilities: self.capabilities,
             payload: self.payload,
         })
     }
@@ -220,6 +229,7 @@ pub struct RegularTransactionEssence {
     #[packable(unpack_error_with = |e| e.unwrap_item_err_or_else(|p| Error::InvalidOutputCount(p.into())))]
     outputs: BoxedSlicePrefix<Output, OutputCount>,
     allotments: ManaAllotments,
+    capabilities: TransactionCapabilities,
     #[packable(verify_with = verify_payload_packable)]
     payload: OptionalPayload,
 }
@@ -268,6 +278,10 @@ impl RegularTransactionEssence {
         &self.allotments
     }
 
+    pub fn capabilities(&self) -> TransactionCapabilities {
+        self.capabilities
+    }
+
     /// Returns the optional payload of a [`RegularTransactionEssence`].
     pub fn payload(&self) -> Option<&Payload> {
         self.payload.as_ref()
@@ -419,6 +433,99 @@ fn verify_payload_packable<const VERIFY: bool>(
     Ok(())
 }
 
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+#[non_exhaustive]
+#[repr(u8)]
+pub enum TransactionCapabilityFlag {
+    BurnNativeTokens = 0b00000001,
+    BurnMana = 0b00000010,
+    DestroyAccountOutputs = 0b00000100,
+    DestroyFoundryOutputs = 0b00001000,
+    DestroyNftOutputs = 0b00010000,
+}
+
+impl TransactionCapabilityFlag {
+    pub fn all() -> impl Iterator<Item = Self> {
+        [
+            Self::BurnNativeTokens,
+            Self::BurnMana,
+            Self::DestroyAccountOutputs,
+            Self::DestroyFoundryOutputs,
+            Self::DestroyNftOutputs,
+        ]
+        .into_iter()
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash, Deref, Packable)]
+#[repr(transparent)]
+pub struct TransactionCapabilities(u8);
+
+impl TransactionCapabilities {
+    pub const NONE: Self = Self(0);
+    pub const ALL: Self = Self(0b00011111);
+
+    pub fn is_all(&self) -> bool {
+        Self::ALL.eq(self)
+    }
+
+    pub fn is_none(&self) -> bool {
+        Self::NONE.eq(self)
+    }
+
+    pub fn set_all(&mut self) -> &mut Self {
+        *self = Self::ALL;
+        self
+    }
+
+    pub fn set_none(&mut self) -> &mut Self {
+        *self = Self::NONE;
+        self
+    }
+
+    pub fn add_capability(&mut self, flag: TransactionCapabilityFlag) -> &mut Self {
+        self.0 |= flag as u8;
+        self
+    }
+
+    pub fn add_capabilities(&mut self, flags: impl IntoIterator<Item = TransactionCapabilityFlag>) -> &mut Self {
+        for flag in flags {
+            self.add_capability(flag);
+        }
+        self
+    }
+
+    pub fn with_capabilities(mut self, flags: impl IntoIterator<Item = TransactionCapabilityFlag>) -> Self {
+        for flag in flags {
+            self.add_capability(flag);
+        }
+        self
+    }
+
+    pub fn set_capabilities(&mut self, flags: impl IntoIterator<Item = TransactionCapabilityFlag>) -> &mut Self {
+        *self = Self::default().with_capabilities(flags);
+        self
+    }
+
+    pub fn has_capability(&self, flag: TransactionCapabilityFlag) -> bool {
+        self.0 & flag as u8 == flag as u8
+    }
+
+    pub fn has_capabilities(&self, flags: impl IntoIterator<Item = TransactionCapabilityFlag>) -> bool {
+        flags.into_iter().all(|flag| self.has_capability(flag))
+    }
+
+    pub fn split(self) -> impl Iterator<Item = TransactionCapabilityFlag> {
+        TransactionCapabilityFlag::all().filter(move |f| self.has_capability(*f))
+    }
+}
+
+impl<I: IntoIterator<Item = TransactionCapabilityFlag>> From<I> for TransactionCapabilities {
+    fn from(value: I) -> Self {
+        Self::default().with_capabilities(value)
+    }
+}
+
 #[cfg(feature = "serde")]
 pub(crate) mod dto {
     use alloc::string::{String, ToString};
@@ -445,6 +552,8 @@ pub(crate) mod dto {
         pub inputs_commitment: String,
         pub outputs: Vec<OutputDto>,
         pub allotments: Vec<ManaAllotmentDto>,
+        // TODO: what does the API want?
+        pub capabilities: u8,
         #[serde(default, skip_serializing_if = "Option::is_none")]
         pub payload: Option<PayloadDto>,
     }
@@ -460,6 +569,7 @@ pub(crate) mod dto {
                 inputs_commitment: value.inputs_commitment().to_string(),
                 outputs: value.outputs().iter().map(Into::into).collect(),
                 allotments: value.mana_allotments().iter().map(Into::into).collect(),
+                capabilities: value.capabilities().0,
                 payload: match value.payload() {
                     Some(p @ Payload::TaggedData(_)) => Some(p.into()),
                     Some(_) => unimplemented!(),
@@ -494,7 +604,8 @@ pub(crate) mod dto {
                 .with_context_inputs(dto.context_inputs)
                 .with_inputs(dto.inputs)
                 .with_outputs(outputs)
-                .with_mana_allotments(mana_allotments);
+                .with_mana_allotments(mana_allotments)
+                .with_capabilities(TransactionCapabilities(dto.capabilities));
 
             builder = if let Some(p) = dto.payload {
                 if let PayloadDto::TaggedData(i) = p {

sdk/src/types/block/payload/transaction/mod.rs

@@ -11,7 +11,10 @@ use packable::{error::UnpackError, packer::Packer, unpacker::Unpacker, Packable,
 
 pub(crate) use self::essence::{ContextInputCount, InputCount, OutputCount};
 pub use self::{
-    essence::{RegularTransactionEssence, RegularTransactionEssenceBuilder, TransactionEssence},
+    essence::{
+        RegularTransactionEssence, RegularTransactionEssenceBuilder, TransactionCapabilities,
+        TransactionCapabilityFlag, TransactionEssence,
+    },
     transaction_id::TransactionId,
 };
 use crate::types::block::{protocol::ProtocolParameters, unlock::Unlocks, Error};