@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0-pr.1545.2

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

@@ -6,6 +6,7 @@ use dpp::errors::consensus::codes::ErrorWithCode;
 use dpp::errors::consensus::ConsensusError;
 
 use crate::buffer::Buffer;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=JsonSchemaError, inspectable)]
@@ -23,27 +24,27 @@ impl From<&JsonSchemaError> for JsonSchemaErrorWasm {
 #[wasm_bindgen(js_class=JsonSchemaError)]
 impl JsonSchemaErrorWasm {
     #[wasm_bindgen(js_name=getKeyword)]
-    pub fn keyword(&self) -> String {
+    pub fn get_keyword(&self) -> String {
         self.inner.keyword().to_string()
     }
 
     #[wasm_bindgen(js_name=getInstancePath)]
-    pub fn instance_path(&self) -> String {
+    pub fn get_instance_path(&self) -> String {
         self.inner.instance_path().to_string()
     }
 
     #[wasm_bindgen(js_name=getSchemaPath)]
-    pub fn schema_path(&self) -> String {
+    pub fn get_schema_path(&self) -> String {
         self.inner.schema_path().to_string()
     }
 
     #[wasm_bindgen(js_name=getPropertyName)]
-    pub fn property_name(&self) -> String {
+    pub fn get_property_name(&self) -> String {
         self.inner.property_name().to_string()
     }
 
     #[wasm_bindgen(js_name=getParams)]
-    pub fn params(&self) -> Result<JsValue, JsError> {
+    pub fn get_params(&self) -> Result<JsValue, JsError> {
         let ser = serde_wasm_bindgen::Serializer::json_compatible();
 
         self.inner.params().serialize(&ser).map_err(|e| e.into())
@@ -64,12 +65,33 @@ impl JsonSchemaErrorWasm {
         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)?;
+    #[wasm_bindgen(getter)]
+    pub fn keyword(&self) -> String {
+        self.get_keyword()
+    }
+
+    #[wasm_bindgen(getter, js_name=instancePath)]
+    pub fn instance_path(&self) -> String {
+        self.get_instance_path()
+    }
+
+    #[wasm_bindgen(getter, js_name=schemaPath)]
+    pub fn schema_path(&self) -> String {
+        self.get_schema_path()
+    }
+
+    #[wasm_bindgen(getter, js_name=propertyName)]
+    pub fn property_name(&self) -> String {
+        self.get_property_name()
+    }
 
-        Ok(Buffer::from_bytes(bytes.as_slice()))
+    #[wasm_bindgen(getter)]
+    pub fn params(&self) -> Result<JsValue, JsError> {
+        self.get_params()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn code(&self) -> u32 {
+        self.get_code()
     }
 }

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

@@ -14,6 +14,7 @@ pub mod state_transition;
 #[cfg(test)]
 mod test_consensus_error;
 mod unsupported_protocol_version_error;
+mod unsupported_version_error;
 mod wrong_public_key_purpose_error;
 
 pub use incompatible_protocol_version_error::*;
@@ -27,4 +28,5 @@ pub use public_key_security_level_not_met_error::*;
 #[cfg(test)]
 pub use test_consensus_error::*;
 pub use unsupported_protocol_version_error::*;
+pub use unsupported_version_error::*;
 pub use wrong_public_key_purpose_error::*;

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

@@ -3,6 +3,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::PublicKeyIsDisabledError;
 use dpp::consensus::ConsensusError;
 use dpp::identity::KeyID;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=PublicKeyIsDisabledError)]
@@ -32,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,12 +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::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
-#[derive(Serialize)]
 #[wasm_bindgen(js_name=PublicKeySecurityLevelNotMetError)]
 pub struct PublicKeySecurityLevelNotMetErrorWasm {
     inner: PublicKeySecurityLevelNotMetError,
@@ -39,13 +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 = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .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,6 +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::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidStateTransitionTypeError)]
@@ -38,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,6 +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::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=MissingStateTransitionTypeError)]
@@ -33,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,6 +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::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=StateTransitionMaxSizeExceededError)]
@@ -36,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,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::UnsupportedProtocolVersionError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=UnsupportedProtocolVersionError)]
@@ -36,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,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::WrongPublicKeyPurposeError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=WrongPublicKeyPurposeError)]
@@ -36,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,10 +73,13 @@ 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,
 };
-use crate::errors::consensus::state::data_contract::DataContractAlreadyPresentErrorWasm;
 use crate::errors::consensus::state::document::{
     DocumentAlreadyPresentErrorWasm, DocumentNotFoundErrorWasm, DocumentOwnerIdMismatchErrorWasm,
     DocumentTimestampWindowViolationErrorWasm, DocumentTimestampsMismatchErrorWasm,
@@ -112,9 +117,12 @@ 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;
+
 pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue {
     match e {
         DPPConsensusError::FeeError(e) => match e {
@@ -176,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()
@@ -197,6 +206,17 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
             let wasm_error: IdentityInsufficientBalanceErrorWasm = e.into();
             wasm_error.into()
         }
+        StateError::DocumentTimestampsAreEqualError(e) => {
+            DocumentTimestampsAreEqualErrorWasm::from(e).into()
+        }
+        StateError::DataContractIsReadonlyError(e) => {
+            DataContractIsReadonlyErrorWasm::from(e).into()
+        }
+        StateError::DataContractConfigUpdateError(e) => {
+            DataContractConfigUpdateErrorWasm::from(e).into()
+        }
+        // TODO(versioning): restore
+        _ => todo!(),
     }
 }
 
@@ -300,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()
@@ -360,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,11 +1,12 @@
 use crate::errors::consensus::consensus_error::from_consensus_error;
 use dpp::consensus::ConsensusError;
+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,7 +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::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)]
@@ -48,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,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::BasicBLSError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=BasicBLSError)]
@@ -26,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,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::BasicECDSAError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=BasicECDSAError)]
@@ -26,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,11 +1,13 @@
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::IdentityNotFoundError;
 use dpp::consensus::ConsensusError;
+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,
@@ -44,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,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::SignatureShouldNotBePresentError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=SignatureShouldNotBePresentError)]
@@ -26,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,8 +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::{PlatformSerializable, PlatformSerializableWithPlatformVersion};
+use dpp::version::PlatformVersion;
 use wasm_bindgen::prelude::*;
-
 #[wasm_bindgen(js_name=DataContractAlreadyPresentError)]
 pub struct DataContractAlreadyPresentErrorWasm {
     inner: DataContractAlreadyPresentError,
@@ -44,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

@@ -0,0 +1,42 @@
+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 wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractConfigUpdateError)]
+pub struct DataContractConfigUpdateErrorWasm {
+    inner: DataContractConfigUpdateError,
+}
+
+impl From<&DataContractConfigUpdateError> for DataContractConfigUpdateErrorWasm {
+    fn from(e: &DataContractConfigUpdateError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractConfigUpdateError)]
+impl DataContractConfigUpdateErrorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(data_contract_id: IdentifierWrapper, message: String) -> Self {
+        Self {
+            inner: DataContractConfigUpdateError::new(data_contract_id.into(), message),
+        }
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> IdentifierWrapper {
+        self.inner.data_contract_id().to_owned().into()
+    }
+
+    #[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/state/data_contract/data_contract_is_readonly_error.rs

@@ -0,0 +1,44 @@
+use crate::buffer::Buffer;
+use crate::identifier::IdentifierWrapper;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::state::data_contract::data_contract_is_readonly_error::DataContractIsReadonlyError;
+use dpp::consensus::ConsensusError;
+
+use dpp::serialization::PlatformSerializable;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractIsReadonlyError)]
+pub struct DataContractIsReadonlyErrorWasm {
+    inner: DataContractIsReadonlyError,
+}
+
+impl From<&DataContractIsReadonlyError> for DataContractIsReadonlyErrorWasm {
+    fn from(e: &DataContractIsReadonlyError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractIsReadonlyError)]
+impl DataContractIsReadonlyErrorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(data_contract_id: IdentifierWrapper) -> Self {
+        Self {
+            inner: DataContractIsReadonlyError::new(data_contract_id.into()),
+        }
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> IdentifierWrapper {
+        self.inner.data_contract_id().to_owned().into()
+    }
+
+    #[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()
+    }
+}