Add commitment input syntactic checks

sdk/src/types/block/payload/error.rs

@@ -52,6 +52,12 @@ pub enum PayloadError {
     MissingCreationSlot,
     #[display(fmt = "input count and unlock count mismatch: {input_count} != {unlock_count}")]
     InputUnlockCountMismatch { input_count: usize, unlock_count: usize },
+    #[display(fmt = "missing commitment context input for staking feature")]
+    MissingCommitmentInputForStakingFeature,
+    #[display(fmt = "missing commitment context input for block issuer feature")]
+    MissingCommitmentInputForBlockIssuerFeature,
+    #[display(fmt = "missing commitment context input for delegation output")]
+    MissingCommitmentInputForDelegationOutput,
     #[from]
     TransactionSemantic(TransactionFailureReason),
     #[from]

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

@@ -187,7 +187,7 @@ impl TransactionBuilder {
             verify_outputs(&outputs, protocol_parameters)?;
         }
 
-        Ok(Transaction {
+        let transaction = Transaction {
             network_id: self.network_id,
             creation_slot,
             context_inputs: ContextInputs::from_vec(self.context_inputs)?,
@@ -196,7 +196,11 @@ impl TransactionBuilder {
             capabilities: self.capabilities,
             payload: self.payload,
             outputs,
-        })
+        };
+
+        verify_transaction(&transaction)?;
+
+        Ok(transaction)
     }
 
     /// Finishes a [`TransactionBuilder`] into a [`Transaction`] without protocol
@@ -213,6 +217,7 @@ pub(crate) type OutputCount = BoundedU16<{ *OUTPUT_COUNT_RANGE.start() }, { *OUT
 #[derive(Clone, Debug, Eq, PartialEq, Packable)]
 #[packable(unpack_error = PayloadError)]
 #[packable(unpack_visitor = ProtocolParameters)]
+#[packable(verify_with = verify_transaction_packable)]
 pub struct Transaction {
     /// The unique value denoting whether the block was meant for mainnet, testnet, or a private network.
     #[packable(verify_with = verify_network_id)]
@@ -439,6 +444,30 @@ fn verify_outputs(outputs: &[Output], visitor: &ProtocolParameters) -> Result<()
     Ok(())
 }
 
+fn verify_transaction_packable(transaction: &Transaction, _: &ProtocolParameters) -> Result<(), PayloadError> {
+    verify_transaction(transaction)
+}
+
+fn verify_transaction(transaction: &Transaction) -> Result<(), PayloadError> {
+    let has_commitment_input = transaction.context_inputs().commitment().is_some();
+
+    for output in transaction.outputs.iter() {
+        if output.features().is_some_and(|f| f.staking().is_some()) && !has_commitment_input {
+            return Err(PayloadError::MissingCommitmentInputForStakingFeature);
+        }
+
+        if output.features().is_some_and(|f| f.block_issuer().is_some()) && !has_commitment_input {
+            return Err(PayloadError::MissingCommitmentInputForBlockIssuerFeature);
+        }
+
+        if output.is_delegation() && !has_commitment_input {
+            return Err(PayloadError::MissingCommitmentInputForDelegationOutput);
+        }
+    }
+
+    Ok(())
+}
+
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 #[non_exhaustive]
 pub enum TransactionCapabilityFlag {

sdk/src/types/block/semantic/mod.rs

@@ -297,9 +297,6 @@ impl<'a> SemanticValidationContext<'a> {
                     if output.features().block_issuer().is_some() {
                         let account_id = output.account_id_non_null(&OutputId::new(self.transaction_id, index as u16));
 
-                        if self.commitment_context_input.is_none() {
-                            return Err(TransactionFailureReason::BlockIssuerCommitmentInputMissing);
-                        }
                         if !bic_context_inputs.contains(&account_id) {
                             return Err(TransactionFailureReason::BlockIssuanceCreditInputMissing);
                         }
@@ -318,9 +315,6 @@ impl<'a> SemanticValidationContext<'a> {
                         }
                     }
                     if output.features().staking().is_some() {
-                        if self.commitment_context_input.is_none() {
-                            return Err(TransactionFailureReason::StakingCommitmentInputMissing);
-                        }
                         if output.features().block_issuer().is_none() {
                             return Err(TransactionFailureReason::StakingBlockIssuerFeatureMissing);
                         }