test(dpp): add deserialization failure tests and fix stale test structs

packages/rs-dpp/src/errors/consensus/basic/unsupported_protocol_version_error.rs

@@ -47,6 +47,7 @@ impl From<UnsupportedProtocolVersionError> for ConsensusError {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::serialization::PlatformDeserializable;
     use crate::serialization::PlatformSerializableWithPlatformVersion;
     use platform_version::version::LATEST_PLATFORM_VERSION;
 
@@ -56,15 +57,13 @@ mod tests {
 
         let consensus_error: ConsensusError = error.clone().into();
 
-        let _cbor = consensus_error
+        let serialized_bytes = consensus_error
             .serialize_to_bytes_with_platform_version(LATEST_PLATFORM_VERSION)
             .expect("should serialize");
 
-        // let value = Value::try_from(&consensus_error).expect("should convert to value");
+        let recovered_consensus_error =
+            ConsensusError::deserialize_from_bytes(&serialized_bytes).expect("should deserialize");
 
-        // let recovered_error: UnsupportedProtocolVersionError =
-        //     value.try_into().expect("should recover from value");
-        //
-        // assert_eq!(recovered_error, error);
+        assert_eq!(consensus_error, recovered_consensus_error);
     }
 }

packages/rs-dpp/src/errors/consensus/basic/unsupported_version_error.rs

@@ -53,6 +53,7 @@ impl From<UnsupportedVersionError> for ConsensusError {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::serialization::PlatformDeserializable;
     use crate::serialization::PlatformSerializableWithPlatformVersion;
     use platform_version::version::LATEST_PLATFORM_VERSION;
 
@@ -62,15 +63,13 @@ mod tests {
 
         let consensus_error: ConsensusError = error.clone().into();
 
-        let _cbor = consensus_error
+        let serialized_bytes = consensus_error
             .serialize_to_bytes_with_platform_version(LATEST_PLATFORM_VERSION)
             .expect("expected to serialize");
 
-        // let value = Value::try_from(&consensus_error).expect("should convert to value");
+        let recovered_consensus_error =
+            ConsensusError::deserialize_from_bytes(&serialized_bytes).expect("should deserialize");
 
-        // let recovered_error: UnsupportedVersionError =
-        //     value.try_into().expect("should recover from value");
-        //
-        // assert_eq!(recovered_error, error);
+        assert_eq!(consensus_error, recovered_consensus_error);
     }
 }

packages/rs-dpp/src/state_transition/serialization.rs

@@ -411,4 +411,156 @@ mod tests {
             .expect("expected to deserialize state transition");
         assert_eq!(state_transition, recovered_state_transition);
     }
+
+    #[test]
+    fn deserialize_empty_bytes_should_fail() {
+        let result = StateTransition::deserialize_from_bytes(&[]);
+        assert!(
+            result.is_err(),
+            "deserialization of empty bytes should fail"
+        );
+    }
+
+    #[test]
+    fn deserialize_single_byte_should_fail() {
+        let result = StateTransition::deserialize_from_bytes(&[0xFF]);
+        assert!(
+            result.is_err(),
+            "deserialization of a single 0xFF byte should fail"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "random-identities")]
+    fn deserialize_truncated_bytes_should_fail() {
+        let platform_version = PlatformVersion::latest();
+        let identity = Identity::random_identity(5, Some(5), platform_version)
+            .expect("expected a random identity");
+        let transition = IdentityCreditWithdrawalTransitionV0 {
+            identity_id: identity.id(),
+            amount: 5000000,
+            core_fee_per_byte: 34,
+            pooling: Pooling::Standard,
+            output_script: CoreScript::from_bytes((0..23).collect::<Vec<u8>>()),
+            nonce: 1,
+            user_fee_increase: 0,
+            signature_public_key_id: 0,
+            signature: [1u8; 65].to_vec().into(),
+        };
+        let state_transition: StateTransition = transition.into();
+        let bytes = state_transition
+            .serialize_to_bytes()
+            .expect("expected to serialize");
+
+        // Truncate to half
+        let half = &bytes[..bytes.len() / 2];
+        assert!(
+            StateTransition::deserialize_from_bytes(half).is_err(),
+            "deserialization of truncated-to-half bytes should fail"
+        );
+
+        // Truncate by removing last byte
+        let minus_one = &bytes[..bytes.len() - 1];
+        assert!(
+            StateTransition::deserialize_from_bytes(minus_one).is_err(),
+            "deserialization of bytes missing last byte should fail"
+        );
+
+        // Keep only first byte
+        let first_only = &bytes[..1];
+        assert!(
+            StateTransition::deserialize_from_bytes(first_only).is_err(),
+            "deserialization of only the first byte should fail"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "random-identities")]
+    fn deserialize_corrupted_bytes_should_not_panic() {
+        let platform_version = PlatformVersion::latest();
+        let identity = Identity::random_identity(5, Some(5), platform_version)
+            .expect("expected a random identity");
+        let transition = IdentityCreditWithdrawalTransitionV0 {
+            identity_id: identity.id(),
+            amount: 5000000,
+            core_fee_per_byte: 34,
+            pooling: Pooling::Standard,
+            output_script: CoreScript::from_bytes((0..23).collect::<Vec<u8>>()),
+            nonce: 1,
+            user_fee_increase: 0,
+            signature_public_key_id: 0,
+            signature: [1u8; 65].to_vec().into(),
+        };
+        let state_transition: StateTransition = transition.into();
+        let mut bytes = state_transition
+            .serialize_to_bytes()
+            .expect("expected to serialize");
+
+        // Flip bits in the middle of the payload
+        let mid = bytes.len() / 2;
+        bytes[mid] ^= 0xFF;
+
+        // Should either fail or return a different value - must not panic
+        let result = StateTransition::deserialize_from_bytes(&bytes);
+        if let Ok(recovered) = result {
+            assert_ne!(
+                state_transition, recovered,
+                "corrupted bytes should not deserialize to the original value"
+            );
+        }
+    }
+
+    #[test]
+    fn deserialize_many_empty_list() {
+        let result = StateTransition::deserialize_many(&[]);
+        assert_eq!(result.unwrap(), vec![]);
+    }
+
+    #[test]
+    fn deserialize_many_with_invalid_entry() {
+        let result = StateTransition::deserialize_many(&[vec![0xFF]]);
+        assert!(
+            result.is_err(),
+            "deserialize_many with invalid entry should fail"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "random-identities")]
+    fn deserialize_many_with_valid_entries() {
+        let platform_version = PlatformVersion::latest();
+        let identity = Identity::random_identity(5, Some(5), platform_version)
+            .expect("expected a random identity");
+
+        let make_transition = |amount: u64, nonce: u64| -> StateTransition {
+            let t = IdentityCreditWithdrawalTransitionV0 {
+                identity_id: identity.id(),
+                amount,
+                core_fee_per_byte: 34,
+                pooling: Pooling::Standard,
+                output_script: CoreScript::from_bytes((0..23).collect::<Vec<u8>>()),
+                nonce,
+                user_fee_increase: 0,
+                signature_public_key_id: 0,
+                signature: [1u8; 65].to_vec().into(),
+            };
+            t.into()
+        };
+
+        let st1 = make_transition(1000000, 1);
+        let st2 = make_transition(2000000, 2);
+        let st3 = make_transition(3000000, 3);
+
+        let raw: Vec<Vec<u8>> = vec![
+            st1.serialize_to_bytes().unwrap(),
+            st2.serialize_to_bytes().unwrap(),
+            st3.serialize_to_bytes().unwrap(),
+        ];
+
+        let recovered = StateTransition::deserialize_many(&raw).expect("should deserialize all");
+        assert_eq!(recovered.len(), 3);
+        assert_eq!(recovered[0], st1);
+        assert_eq!(recovered[1], st2);
+        assert_eq!(recovered[2], st3);
+    }
 }