@dashevo/wasm-dpp 0.25.0-dev.16 → 0.25.0-dev.18

package/src/errors/consensus/basic/public_key_is_disabled_error.rs

@@ -3,7 +3,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::PublicKeyIsDisabledError;
 use dpp::consensus::ConsensusError;
 use dpp::identity::KeyID;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=PublicKeyIsDisabledError)]
@@ -33,13 +33,4 @@ impl PublicKeyIsDisabledErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/basic/public_key_security_level_not_met_error.rs

@@ -1,13 +1,12 @@
 use crate::buffer::Buffer;
-use crate::Serialize;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::PublicKeySecurityLevelNotMetError;
 use dpp::consensus::ConsensusError;
+use serde::Serialize;
 
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
-#[derive(Serialize)]
 #[wasm_bindgen(js_name=PublicKeySecurityLevelNotMetError)]
 pub struct PublicKeySecurityLevelNotMetErrorWasm {
     inner: PublicKeySecurityLevelNotMetError,
@@ -40,12 +39,4 @@ impl PublicKeySecurityLevelNotMetErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = PlatformSerializable::serialize(&ConsensusError::from(self.inner.clone()))
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::state_transition::InvalidStateTransitionTypeError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidStateTransitionTypeError)]
@@ -39,13 +39,4 @@ impl InvalidStateTransitionTypeErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/basic/state_transition/missing_state_transition_type_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::state_transition::MissingStateTransitionTypeError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=MissingStateTransitionTypeError)]
@@ -34,13 +34,4 @@ impl MissingStateTransitionTypeErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::state_transition::StateTransitionMaxSizeExceededError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=StateTransitionMaxSizeExceededError)]
@@ -37,13 +37,4 @@ impl StateTransitionMaxSizeExceededErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/basic/unsupported_protocol_version_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::UnsupportedProtocolVersionError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=UnsupportedProtocolVersionError)]
@@ -37,13 +37,4 @@ impl UnsupportedProtocolVersionErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/basic/unsupported_version_error.rs

@@ -0,0 +1,44 @@
+use crate::buffer::Buffer;
+use dpp::consensus::basic::UnsupportedVersionError;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = UnsupportedVersionError)]
+pub struct UnsupportedVersionErrorWasm {
+    inner: UnsupportedVersionError,
+}
+
+impl From<&UnsupportedVersionError> for UnsupportedVersionErrorWasm {
+    fn from(e: &UnsupportedVersionError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class = UnsupportedVersionError)]
+impl UnsupportedVersionErrorWasm {
+    #[wasm_bindgen(js_name = getReceivedVersion)]
+    pub fn received_version(&self) -> u16 {
+        self.inner.received_version()
+    }
+
+    #[wasm_bindgen(js_name = getMinVersion)]
+    pub fn min_version(&self) -> u16 {
+        self.inner.min_version()
+    }
+
+    #[wasm_bindgen(js_name = getMaxVersion)]
+    pub fn max_version(&self) -> u16 {
+        self.inner.max_version()
+    }
+
+    #[wasm_bindgen(js_name = getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+}

package/src/errors/consensus/basic/wrong_public_key_purpose_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::WrongPublicKeyPurposeError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=WrongPublicKeyPurposeError)]
@@ -37,13 +37,4 @@ impl WrongPublicKeyPurposeErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/consensus_error.rs

@@ -1,8 +1,8 @@
 use crate::errors::consensus::basic::{
     IncompatibleProtocolVersionErrorWasm, InvalidIdentifierErrorWasm, JsonSchemaErrorWasm,
-    UnsupportedProtocolVersionErrorWasm,
+    UnsupportedProtocolVersionErrorWasm, UnsupportedVersionErrorWasm,
 };
-use dpp::consensus::ConsensusError as DPPConsensusError;
+use dpp::consensus::{ConsensusError as DPPConsensusError, ConsensusError};
 use std::ops::Deref;
 
 use crate::errors::consensus::basic::identity::{
@@ -23,6 +23,7 @@ use crate::errors::consensus::basic::identity::{
     InvalidInstantAssetLockProofSignatureErrorWasm, MissingMasterPublicKeyErrorWasm,
     NotImplementedIdentityCreditWithdrawalTransitionPoolingErrorWasm,
 };
+
 use crate::errors::consensus::state::identity::{
     DuplicatedIdentityPublicKeyIdStateErrorWasm, DuplicatedIdentityPublicKeyStateErrorWasm,
     MissingIdentityPublicKeyIdsErrorWasm,
@@ -43,12 +44,13 @@ use dpp::consensus::basic::BasicError::{
     InvalidIdentityPublicKeySecurityLevelError, InvalidInstantAssetLockProofError,
     InvalidInstantAssetLockProofSignatureError, JsonSchemaError, MissingMasterPublicKeyError,
     NotImplementedIdentityCreditWithdrawalTransitionPoolingError, ProtocolVersionParsingError,
-    SerializedObjectParsingError, UnsupportedProtocolVersionError,
+    SerializedObjectParsingError, UnsupportedProtocolVersionError, UnsupportedVersionError,
 };
 use dpp::consensus::fee::fee_error::FeeError;
 use dpp::consensus::signature::SignatureError;
 
-use dpp::consensus::state::data_trigger::data_trigger_error::DataTriggerError;
+// TODO(versioning): remove
+// use dpp::consensus::state::data_trigger::data_trigger_error::DataTriggerError;
 use dpp::consensus::state::state_error::StateError;
 
 use wasm_bindgen::{JsError, JsValue};
@@ -71,9 +73,9 @@ use crate::errors::consensus::signature::{
     BasicBLSErrorWasm, BasicECDSAErrorWasm, IdentityNotFoundErrorWasm,
     SignatureShouldNotBePresentErrorWasm,
 };
-use crate::errors::consensus::state::data_contract::data_trigger::{
-    DataTriggerConditionErrorWasm, DataTriggerExecutionErrorWasm,
-};
+// use crate::errors::consensus::state::data_contract::data_trigger::{
+//     DataTriggerConditionErrorWasm, DataTriggerExecutionErrorWasm,
+// };
 use crate::errors::consensus::state::data_contract::{
     DataContractAlreadyPresentErrorWasm, DataContractConfigUpdateErrorWasm,
     DataContractIsReadonlyErrorWasm,
@@ -115,7 +117,8 @@ use crate::errors::consensus::basic::{
     PublicKeySecurityLevelNotMetErrorWasm, WrongPublicKeyPurposeErrorWasm,
 };
 use crate::errors::consensus::fee::BalanceIsNotEnoughErrorWasm;
-use crate::errors::consensus::state::data_contract::data_trigger::DataTriggerInvalidResultErrorWasm;
+
+// use crate::errors::consensus::state::data_contract::data_trigger::DataTriggerInvalidResultErrorWasm;
 use crate::errors::consensus::value_error::ValueErrorWasm;
 
 use super::state::document::DocumentTimestampsAreEqualErrorWasm;
@@ -181,19 +184,20 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::MissingIdentityPublicKeyIdsError(e) => {
             MissingIdentityPublicKeyIdsErrorWasm::from(e).into()
         }
-        StateError::DataTriggerError(data_trigger_error) => match data_trigger_error.deref() {
-            DataTriggerError::DataTriggerConditionError(e) => {
-                DataTriggerConditionErrorWasm::from(e).into()
-            }
-            DataTriggerError::DataTriggerExecutionError(e) => {
-                DataTriggerExecutionErrorWasm::from(e).into()
-            }
-            DataTriggerError::DataTriggerInvalidResultError(e) => {
-                DataTriggerInvalidResultErrorWasm::from(e).into()
-            }
-        },
-        // TODO(v0.24-backport): this error seems to be used only in drive executor. Do we need binding for it?
-        StateError::DataTriggerActionError(_) => JsError::new("Data Trigger action error").into(),
+        // TODO(versioning): restore
+        // StateError::DataTriggerError(data_trigger_error) => match data_trigger_error.deref() {
+        //     DataTriggerError::DataTriggerConditionError(e) => {
+        //         DataTriggerConditionErrorWasm::from(e).into()
+        //     }
+        //     DataTriggerError::DataTriggerExecutionError(e) => {
+        //         DataTriggerExecutionErrorWasm::from(e).into()
+        //     }
+        //     DataTriggerError::DataTriggerInvalidResultError(e) => {
+        //         DataTriggerInvalidResultErrorWasm::from(e).into()
+        //     }
+        // },
+        // TODO(versioning): restore
+        // StateError::DataTriggerActionError(_) => JsError::new("Data Trigger action error").into(),
         StateError::IdentityAlreadyExistsError(e) => {
             let wasm_error: IdentityAlreadyExistsErrorWasm = e.into();
             wasm_error.into()
@@ -211,6 +215,8 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::DataContractConfigUpdateError(e) => {
             DataContractConfigUpdateErrorWasm::from(e).into()
         }
+        // TODO(versioning): restore
+        _ => todo!(),
     }
 }
 
@@ -314,6 +320,7 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         SerializedObjectParsingError(e) => SerializedObjectParsingErrorWasm::from(e).into(),
         JsonSchemaError(e) => JsonSchemaErrorWasm::from(e).into(),
         UnsupportedProtocolVersionError(e) => UnsupportedProtocolVersionErrorWasm::from(e).into(),
+        UnsupportedVersionError(e) => UnsupportedVersionErrorWasm::from(e).into(),
         IncompatibleProtocolVersionError(e) => IncompatibleProtocolVersionErrorWasm::from(e).into(),
         DuplicatedIdentityPublicKeyIdBasicError(e) => {
             DuplicatedIdentityPublicKeyIdErrorWasm::from(e).into()
@@ -374,6 +381,8 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
             NotImplementedIdentityCreditWithdrawalTransitionPoolingErrorWasm::from(e).into()
         }
         IncompatibleRe2PatternError(err) => IncompatibleRe2PatternErrorWasm::from(err).into(),
+        // TODO(versioning): cover other errors
+        _ => todo!(),
     }
 }
 

package/src/errors/consensus/deserialize.rs

@@ -1,12 +1,12 @@
 use crate::errors::consensus::consensus_error::from_consensus_error;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformDeserializable;
+use dpp::serialization::PlatformDeserializable;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::{JsError, JsValue};
 
 #[wasm_bindgen(js_name=deserializeConsensusError)]
 pub fn deserialize_consensus_error(bytes: Vec<u8>) -> Result<JsValue, JsError> {
-    ConsensusError::deserialize(bytes.as_slice())
+    ConsensusError::deserialize_from_bytes(bytes.as_slice())
         .map(from_consensus_error)
         .map_err(|e| e.into())
 }

package/src/errors/consensus/fee/balance_is_not_enough_error.rs

@@ -2,8 +2,10 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::fee::balance_is_not_enough_error::BalanceIsNotEnoughError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
-use dpp::state_transition::fee::Credits;
+use dpp::fee::Credits;
+use dpp::serialization::PlatformSerializable;
+use dpp::serialization::PlatformSerializableWithPlatformVersion;
+use dpp::version::PlatformVersion;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=BalanceIsNotEnoughError)]
@@ -49,7 +51,7 @@ impl BalanceIsNotEnoughErrorWasm {
     #[wasm_bindgen(js_name=serialize)]
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
+            .serialize_to_bytes_with_platform_version(PlatformVersion::first())
             .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))

package/src/errors/consensus/signature/basic_bls_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::BasicBLSError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=BasicBLSError)]
@@ -27,13 +27,4 @@ impl BasicBLSErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/signature/basic_ecdsa_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::BasicECDSAError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=BasicECDSAError)]
@@ -27,13 +27,4 @@ impl BasicECDSAErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/signature/identity_not_found_error.rs

@@ -1,12 +1,13 @@
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::IdentityNotFoundError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
 use crate::identifier::IdentifierWrapper;
-
+use dpp::serialization::PlatformSerializableWithPlatformVersion;
+use dpp::version::PlatformVersion;
 #[wasm_bindgen(js_name=IdentityNotFoundError)]
 pub struct IdentityNotFoundErrorWasm {
     inner: IdentityNotFoundError,
@@ -45,7 +46,7 @@ impl IdentityNotFoundErrorWasm {
     #[wasm_bindgen(js_name=serialize)]
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
+            .serialize_to_bytes_with_platform_version(PlatformVersion::first())
             .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))

package/src/errors/consensus/signature/signature_should_not_be_present_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::SignatureShouldNotBePresentError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=SignatureShouldNotBePresentError)]
@@ -27,13 +27,4 @@ impl SignatureShouldNotBePresentErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/data_contract/data_contract_already_present_error.rs

@@ -4,9 +4,9 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::data_contract::data_contract_already_present_error::DataContractAlreadyPresentError;
 use dpp::consensus::ConsensusError;
 
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::{PlatformSerializable, PlatformSerializableWithPlatformVersion};
+use dpp::version::PlatformVersion;
 use wasm_bindgen::prelude::*;
-
 #[wasm_bindgen(js_name=DataContractAlreadyPresentError)]
 pub struct DataContractAlreadyPresentErrorWasm {
     inner: DataContractAlreadyPresentError,
@@ -45,7 +45,7 @@ impl DataContractAlreadyPresentErrorWasm {
     #[wasm_bindgen(js_name=serialize)]
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
+            .serialize_to_bytes_with_platform_version(PlatformVersion::first())
             .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))

package/src/errors/consensus/state/data_contract/data_contract_config_update_error.rs

@@ -1,10 +1,8 @@
-use crate::buffer::Buffer;
 use crate::identifier::IdentifierWrapper;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::data_contract::data_contract_config_update_error::DataContractConfigUpdateError;
-use dpp::consensus::ConsensusError;
 
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::consensus::ConsensusError;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataContractConfigUpdateError)]
@@ -41,13 +39,4 @@ impl DataContractConfigUpdateErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/data_contract/data_contract_is_readonly_error.rs

@@ -4,7 +4,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::data_contract::data_contract_is_readonly_error::DataContractIsReadonlyError;
 use dpp::consensus::ConsensusError;
 
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataContractIsReadonlyError)]
@@ -41,13 +41,4 @@ impl DataContractIsReadonlyErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_condition_error.rs

@@ -4,7 +4,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::data_trigger::data_trigger_condition_error::DataTriggerConditionError;
 use dpp::consensus::ConsensusError;
 use dpp::identifier::Identifier;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerConditionError)]
@@ -48,7 +48,7 @@ impl DataTriggerConditionErrorWasm {
     #[wasm_bindgen(js_name=serialize)]
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
+            .serialize_to_bytes()
             .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_execution_error.rs

@@ -3,7 +3,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::data_trigger::data_trigger_execution_error::DataTriggerExecutionError;
 use dpp::consensus::ConsensusError;
 use dpp::identifier::Identifier;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerExecutionError)]
@@ -47,7 +47,7 @@ impl DataTriggerExecutionErrorWasm {
     #[wasm_bindgen(js_name=serialize)]
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
+            .serialize_to_bytes()
             .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_invalid_result_error.rs

@@ -4,7 +4,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::data_trigger::data_trigger_invalid_result_error::DataTriggerInvalidResultError;
 use dpp::consensus::ConsensusError;
 use dpp::identifier::Identifier;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerInvalidResultError)]
@@ -43,7 +43,7 @@ impl DataTriggerInvalidResultErrorWasm {
     #[wasm_bindgen(js_name=serialize)]
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
+            .serialize_to_bytes()
             .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))

package/src/errors/consensus/state/data_contract/mod.rs

@@ -1,7 +1,9 @@
 mod data_contract_already_present_error;
 mod data_contract_config_update_error;
 mod data_contract_is_readonly_error;
-pub mod data_trigger;
+
+// TODO(versioning): remove
+// pub mod data_trigger;
 
 pub use data_contract_already_present_error::*;
 pub use data_contract_config_update_error::*;

package/src/errors/consensus/state/document/document_already_present_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_already_present_error::DocumentAlreadyPresentError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentAlreadyPresentError)]
@@ -32,13 +32,4 @@ impl DocumentAlreadyPresentErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/document/document_not_found_error.rs

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_not_found_error::DocumentNotFoundError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentNotFoundError)]
@@ -32,13 +32,4 @@ impl DocumentNotFoundErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }