feat(sdk): add client-side validate_base_structure for document and token transitions

Add structural validation to all document and token SDK transition
builders, matching the pattern from PR dashpay#3096 (identity/address
transitions). Calls validate_base_structure() on BatchTransition after
construction but before broadcast, catching invalid transitions early.

Applied to:
- Document transitions: create, delete, replace, purchase, set_price, transfer
- Token builders: burn, claim, config_update, destroy, purchase,
  emergency_action, freeze, mint, set_price, transfer, unfreeze
- Enabled dpp 'validation' feature for dash-sdk crate

Author: thepastaclaw

.gitignore

@@ -85,3 +85,4 @@ packages/wasm-sdk/extracted_definitions.json
 
 # gRPC coverage report
 grpc-coverage-report.txt
+worktrees/

packages/rs-sdk/Cargo.toml

@@ -9,6 +9,7 @@ arc-swap = { version = "1.7.1" }
 chrono = { version = "0.4.38" }
 dpp = { path = "../rs-dpp", default-features = false, features = [
   "dash-sdk-features",
+  "validation",
 ] }
 dapi-grpc = { path = "../dapi-grpc", default-features = false }
 rs-dapi-client = { path = "../rs-dapi-client", default-features = false }

packages/rs-sdk/src/platform/documents/transitions/create.rs

@@ -167,6 +167,22 @@ impl DocumentCreateTransitionBuilder {
             self.state_transition_creation_options,
         )?;
 
+        // Validate the transition structure before returning
+        let validation_result = match &state_transition {
+            StateTransition::Batch(batch_transition) => {
+                batch_transition.validate_base_structure(platform_version)?
+            }
+            _ => {
+                return Err(Error::Protocol(dpp::ProtocolError::InvalidStateTransitionType(
+                    "expected Batch transition".to_string(),
+                )));
+            }
+        };
+        if !validation_result.is_valid() {
+            let first_error = validation_result.errors.into_iter().next().unwrap();
+            return Err(Error::Protocol(dpp::ProtocolError::ConsensusError(Box::new(first_error))));
+        }
+
         Ok(state_transition)
     }
 }

packages/rs-sdk/src/platform/documents/transitions/delete.rs

@@ -207,6 +207,22 @@ impl DocumentDeleteTransitionBuilder {
             self.state_transition_creation_options,
         )?;
 
+        // Validate the transition structure before returning
+        let validation_result = match &state_transition {
+            StateTransition::Batch(batch_transition) => {
+                batch_transition.validate_base_structure(platform_version)?
+            }
+            _ => {
+                return Err(Error::Protocol(dpp::ProtocolError::InvalidStateTransitionType(
+                    "expected Batch transition".to_string(),
+                )));
+            }
+        };
+        if !validation_result.is_valid() {
+            let first_error = validation_result.errors.into_iter().next().unwrap();
+            return Err(Error::Protocol(dpp::ProtocolError::ConsensusError(Box::new(first_error))));
+        }
+
         Ok(state_transition)
     }
 }

packages/rs-sdk/src/platform/documents/transitions/purchase.rs

@@ -221,6 +221,22 @@ impl DocumentPurchaseTransitionBuilder {
             self.state_transition_creation_options,
         )?;
 
+        // Validate the transition structure before returning
+        let validation_result = match &state_transition {
+            StateTransition::Batch(batch_transition) => {
+                batch_transition.validate_base_structure(platform_version)?
+            }
+            _ => {
+                return Err(Error::Protocol(dpp::ProtocolError::InvalidStateTransitionType(
+                    "expected Batch transition".to_string(),
+                )));
+            }
+        };
+        if !validation_result.is_valid() {
+            let first_error = validation_result.errors.into_iter().next().unwrap();
+            return Err(Error::Protocol(dpp::ProtocolError::ConsensusError(Box::new(first_error))));
+        }
+
         Ok(state_transition)
     }
 }

packages/rs-sdk/src/platform/documents/transitions/replace.rs

@@ -160,6 +160,22 @@ impl DocumentReplaceTransitionBuilder {
             self.state_transition_creation_options,
         )?;
 
+        // Validate the transition structure before returning
+        let validation_result = match &state_transition {
+            StateTransition::Batch(batch_transition) => {
+                batch_transition.validate_base_structure(platform_version)?
+            }
+            _ => {
+                return Err(Error::Protocol(dpp::ProtocolError::InvalidStateTransitionType(
+                    "expected Batch transition".to_string(),
+                )));
+            }
+        };
+        if !validation_result.is_valid() {
+            let first_error = validation_result.errors.into_iter().next().unwrap();
+            return Err(Error::Protocol(dpp::ProtocolError::ConsensusError(Box::new(first_error))));
+        }
+
         Ok(state_transition)
     }
 }

packages/rs-sdk/src/platform/documents/transitions/set_price.rs

@@ -208,6 +208,22 @@ impl DocumentSetPriceTransitionBuilder {
             self.state_transition_creation_options,
         )?;
 
+        // Validate the transition structure before returning
+        let validation_result = match &state_transition {
+            StateTransition::Batch(batch_transition) => {
+                batch_transition.validate_base_structure(platform_version)?
+            }
+            _ => {
+                return Err(Error::Protocol(dpp::ProtocolError::InvalidStateTransitionType(
+                    "expected Batch transition".to_string(),
+                )));
+            }
+        };
+        if !validation_result.is_valid() {
+            let first_error = validation_result.errors.into_iter().next().unwrap();
+            return Err(Error::Protocol(dpp::ProtocolError::ConsensusError(Box::new(first_error))));
+        }
+
         Ok(state_transition)
     }
 }

packages/rs-sdk/src/platform/documents/transitions/transfer.rs

@@ -207,6 +207,22 @@ impl DocumentTransferTransitionBuilder {
             self.state_transition_creation_options,
         )?;
 
+        // Validate the transition structure before returning
+        let validation_result = match &state_transition {
+            StateTransition::Batch(batch_transition) => {
+                batch_transition.validate_base_structure(platform_version)?
+            }
+            _ => {
+                return Err(Error::Protocol(dpp::ProtocolError::InvalidStateTransitionType(
+                    "expected Batch transition".to_string(),
+                )));
+            }
+        };
+        if !validation_result.is_valid() {
+            let first_error = validation_result.errors.into_iter().next().unwrap();
+            return Err(Error::Protocol(dpp::ProtocolError::ConsensusError(Box::new(first_error))));
+        }
+
         Ok(state_transition)
     }
 }

packages/rs-sdk/src/platform/tokens/builders/burn.rs

@@ -179,6 +179,22 @@ impl TokenBurnTransitionBuilder {
             self.state_transition_creation_options,
         )?;
 
+        // Validate the transition structure before returning
+        let validation_result = match &state_transition {
+            StateTransition::Batch(batch_transition) => {
+                batch_transition.validate_base_structure(platform_version)?
+            }
+            _ => {
+                return Err(Error::Protocol(dpp::ProtocolError::InvalidStateTransitionType(
+                    "expected Batch transition".to_string(),
+                )));
+            }
+        };
+        if !validation_result.is_valid() {
+            let first_error = validation_result.errors.into_iter().next().unwrap();
+            return Err(Error::Protocol(dpp::ProtocolError::ConsensusError(Box::new(first_error))));
+        }
+
         Ok(state_transition)
     }
 }

packages/rs-sdk/src/platform/tokens/builders/claim.rs

@@ -165,6 +165,22 @@ impl TokenClaimTransitionBuilder {
             self.state_transition_creation_options,
         )?;
 
+        // Validate the transition structure before returning
+        let validation_result = match &state_transition {
+            StateTransition::Batch(batch_transition) => {
+                batch_transition.validate_base_structure(platform_version)?
+            }
+            _ => {
+                return Err(Error::Protocol(dpp::ProtocolError::InvalidStateTransitionType(
+                    "expected Batch transition".to_string(),
+                )));
+            }
+        };
+        if !validation_result.is_valid() {
+            let first_error = validation_result.errors.into_iter().next().unwrap();
+            return Err(Error::Protocol(dpp::ProtocolError::ConsensusError(Box::new(first_error))));
+        }
+
         Ok(state_transition)
     }
 }