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

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

@@ -4,6 +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::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerConditionError)]
@@ -47,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,6 +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::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerExecutionError)]
@@ -46,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,6 +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::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerInvalidResultError)]
@@ -42,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,4 +1,10 @@
 mod data_contract_already_present_error;
-pub mod data_trigger;
+mod data_contract_config_update_error;
+mod data_contract_is_readonly_error;
+
+// TODO(versioning): remove
+// pub mod data_trigger;
 
 pub use data_contract_already_present_error::*;
+pub use data_contract_config_update_error::*;
+pub use data_contract_is_readonly_error::*;

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

@@ -2,6 +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::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentAlreadyPresentError)]
@@ -31,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,6 +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::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentNotFoundError)]
@@ -31,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()))
-    }
 }

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

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_owner_id_mismatch_error::DocumentOwnerIdMismatchError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentOwnerIdMismatchError)]
@@ -41,13 +42,4 @@ impl DocumentOwnerIdMismatchErrorWasm {
     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_timestamp_window_violation_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_timestamp_window_violation_error::DocumentTimestampWindowViolationError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentTimestampWindowViolationError)]
@@ -57,13 +58,4 @@ impl DocumentTimestampWindowViolationErrorWasm {
     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_timestamps_are_equal_error.rs

@@ -0,0 +1,34 @@
+use crate::buffer::Buffer;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::state::document::document_timestamps_are_equal_error::DocumentTimestampsAreEqualError;
+use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentTimestampsAreEqualError)]
+pub struct DocumentTimestampsAreEqualErrorWasm {
+    inner: DocumentTimestampsAreEqualError,
+}
+
+impl From<&DocumentTimestampsAreEqualError> for DocumentTimestampsAreEqualErrorWasm {
+    fn from(e: &DocumentTimestampsAreEqualError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+#[wasm_bindgen(js_class=DocumentTimestampsAreEqualError)]
+impl DocumentTimestampsAreEqualErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.inner.document_id().as_bytes())
+    }
+
+    #[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/document/document_timestamps_mismatch_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_timestamps_mismatch_error::DocumentTimestampsMismatchError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentTimestampsMismatchError)]
@@ -30,13 +31,4 @@ impl DocumentTimestampsMismatchErrorWasm {
     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/duplicate_unique_index_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::duplicate_unique_index_error::DuplicateUniqueIndexError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use js_sys::JsString;
 use wasm_bindgen::prelude::*;
 
@@ -41,13 +42,4 @@ impl DuplicateUniqueIndexErrorWasm {
     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/invalid_document_revision_error.rs

@@ -3,6 +3,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::invalid_document_revision_error::InvalidDocumentRevisionError;
 use dpp::consensus::ConsensusError;
 use dpp::prelude::Revision;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidDocumentRevisionError)]
@@ -23,9 +24,14 @@ impl InvalidDocumentRevisionErrorWasm {
         Buffer::from_bytes(self.inner.document_id().as_bytes())
     }
 
-    #[wasm_bindgen(js_name=getCurrentRevision)]
-    pub fn current_revision(&self) -> Option<Revision> {
-        *self.inner.current_revision()
+    #[wasm_bindgen(js_name=getPreviousRevision)]
+    pub fn previous_revision(&self) -> Option<Revision> {
+        *self.inner.previous_revision()
+    }
+
+    #[wasm_bindgen(js_name=getDesiredRevision)]
+    pub fn desired_revision(&self) -> Revision {
+        *self.inner.desired_revision()
     }
 
     #[wasm_bindgen(js_name=getCode)]
@@ -37,13 +43,4 @@ impl InvalidDocumentRevisionErrorWasm {
     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/mod.rs

@@ -2,6 +2,7 @@ mod document_already_present_error;
 mod document_not_found_error;
 mod document_owner_id_mismatch_error;
 mod document_timestamp_window_violation_error;
+mod document_timestamps_are_equal_error;
 mod document_timestamps_mismatch_error;
 mod duplicate_unique_index_error;
 mod invalid_document_revision_error;
@@ -10,6 +11,7 @@ pub use document_already_present_error::*;
 pub use document_not_found_error::*;
 pub use document_owner_id_mismatch_error::*;
 pub use document_timestamp_window_violation_error::*;
+pub use document_timestamps_are_equal_error::*;
 pub use document_timestamps_mismatch_error::*;
 pub use duplicate_unique_index_error::*;
 pub use invalid_document_revision_error::*;

package/src/errors/consensus/state/identity/duplicated_identity_public_key_id_state_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::duplicated_identity_public_key_id_state_error::DuplicatedIdentityPublicKeyIdStateError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DuplicatedIdentityPublicKeyIdStateError)]
@@ -38,13 +39,4 @@ impl DuplicatedIdentityPublicKeyIdStateErrorWasm {
     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/identity/duplicated_identity_public_key_state_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::duplicated_identity_public_key_state_error::DuplicatedIdentityPublicKeyStateError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DuplicatedIdentityPublicKeyStateError)]
@@ -35,13 +36,4 @@ impl DuplicatedIdentityPublicKeyStateErrorWasm {
     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/identity/identity_already_exists_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::IdentityAlreadyExistsError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityAlreadyExistsError)]
@@ -31,13 +32,4 @@ impl IdentityAlreadyExistsErrorWasm {
     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/identity/identity_public_key_disabled_at_window_violation_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::identity_public_key_disabled_at_window_violation_error::IdentityPublicKeyDisabledAtWindowViolationError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKeyDisabledAtWindowViolationError)]
@@ -46,13 +47,4 @@ impl IdentityPublicKeyDisabledAtWindowViolationErrorWasm {
     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/identity/identity_public_key_is_disabled_error.rs

@@ -3,6 +3,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::identity_public_key_is_disabled_error::IdentityPublicKeyIsDisabledError;
 use dpp::consensus::ConsensusError;
 use dpp::identity::KeyID;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKeyIsDisabledError)]
@@ -32,13 +33,4 @@ impl IdentityPublicKeyIsDisabledErrorWasm {
     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/identity/identity_public_key_is_read_only_error.rs

@@ -3,6 +3,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::identity_public_key_is_read_only_error::IdentityPublicKeyIsReadOnlyError;
 use dpp::consensus::ConsensusError;
 use dpp::identity::KeyID;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKeyIsReadOnlyError)]
@@ -37,13 +38,4 @@ impl IdentityPublicKeyIsReadOnlyErrorWasm {
     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/identity/invalid_identity_public_key_id_error.rs

@@ -3,6 +3,8 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::invalid_identity_public_key_id_error::InvalidIdentityPublicKeyIdError;
 use dpp::consensus::ConsensusError;
 use dpp::identity::KeyID;
+use dpp::serialization::{PlatformSerializable, PlatformSerializableWithPlatformVersion};
+use dpp::version::PlatformVersion;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidIdentityPublicKeyIdError)]
@@ -32,13 +34,4 @@ impl InvalidIdentityPublicKeyIdErrorWasm {
     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/identity/invalid_identity_revision_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::invalid_identity_revision_error::InvalidIdentityRevisionError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use js_sys::Number;
 use wasm_bindgen::prelude::*;
 
@@ -38,13 +39,4 @@ impl InvalidIdentityRevisionErrorWasm {
     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/identity/max_identity_public_key_limit_reached_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::max_identity_public_key_limit_reached_error::MaxIdentityPublicKeyLimitReachedError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=MaxIdentityPublicKeyLimitReachedError)]
@@ -32,13 +33,4 @@ impl MaxIdentityPublicKeyLimitReachedErrorWasm {
     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/value_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::value_error::ValueError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=ValueError, inspectable)]
@@ -32,13 +33,4 @@ impl ValueErrorWasm {
     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/from.rs

@@ -5,6 +5,7 @@ use dpp::errors::ProtocolError;
 
 use crate::data_contract::errors::from_data_contract_to_js_error;
 use crate::document::errors::from_document_to_js_error;
+// use crate::document::errors::from_document_to_js_error;
 use crate::errors::value_error::PlatformValueErrorWasm;
 
 use super::data_contract_not_present_error::DataContractNotPresentNotConsensusErrorWasm;
@@ -12,19 +13,20 @@ use crate::errors::consensus::consensus_error::from_consensus_error;
 
 pub fn from_dpp_err(pe: ProtocolError) -> JsValue {
     match pe {
+        // TODO(versioning): restore this
         ProtocolError::ConsensusError(consensus_error) => from_consensus_error(*consensus_error),
         ProtocolError::DataContractError(e) => from_data_contract_to_js_error(e),
 
         ProtocolError::Document(e) => from_document_to_js_error(*e),
 
-        ProtocolError::ParsingJsonError(err) => format!(
-            "Parsing error at line {}, column {}: {}",
-            err.line(),
-            err.column(),
-            err
-        )
-        .into(),
-
+        // ProtocolError::ParsingJsonError(err) => format!(
+        //     "Parsing error at line {}, column {}: {}",
+        //     err.line(),
+        //     err.column(),
+        //     err
+        // )
+        // .into(),
+        //
         ProtocolError::DataContractNotPresentError(err) => {
             DataContractNotPresentNotConsensusErrorWasm::new(err.data_contract_id()).into()
         }
@@ -38,5 +40,7 @@ pub fn from_dpp_init_error(e: DashPlatformProtocolInitError) -> JsValue {
         DashPlatformProtocolInitError::SchemaDeserializationError(e) => e.to_string().into(),
         DashPlatformProtocolInitError::ValidationError(e) => e.to_string().into(),
         DashPlatformProtocolInitError::InvalidSchemaError(e) => e.to_string().into(),
+        // TODO(versioning): add rest erros
+        _ => JsValue::from_str(&format!("Error conversion not implemented: {e:#}",)),
     }
 }

package/src/errors/mod.rs

@@ -6,12 +6,12 @@ pub mod consensus;
 mod from;
 mod js_conversion;
 pub mod protocol_error;
-mod public_key_validation_error;
-
-pub use public_key_validation_error::*;
-
-mod compatible_protocol_version_is_not_defined_error;
+// mod public_key_validation_error;
+//
+// pub use public_key_validation_error::*;
+//
+// mod compatible_protocol_version_is_not_defined_error;
 pub mod data_contract_not_present_error;
-pub mod dpp_error;
+// pub mod dpp_error;
 pub mod value_error;
-pub use compatible_protocol_version_is_not_defined_error::*;
+// pub use compatible_protocol_version_is_not_defined_error::*;

package/src/errors/value_error.rs

@@ -29,4 +29,9 @@ impl PlatformValueErrorWasm {
     pub fn to_string(&self) -> String {
         format!("PlatformValueError: {}", self.message)
     }
+
+    #[wasm_bindgen(js_name=valueOf)]
+    pub fn value_of(&self) -> String {
+        self.to_string()
+    }
 }

package/src/identity/errors/asset_lock_transaction_is_not_found_error.rs

@@ -1,4 +1,3 @@
-use dpp::dashcore::hashes::hex::ToHex;
 use dpp::identity::errors::AssetLockTransactionIsNotFoundError;
 use wasm_bindgen::prelude::*;
 
@@ -15,6 +14,6 @@ impl From<&AssetLockTransactionIsNotFoundError> for AssetLockTransactionIsNotFou
 impl AssetLockTransactionIsNotFoundErrorWasm {
     #[wasm_bindgen(js_name=getTransactionId)]
     pub fn transaction_id(&self) -> JsValue {
-        self.0.transaction_id().to_hex().into()
+        hex::encode(self.0.transaction_id()).into()
     }
 }