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

package/src/errors/consensus/basic/identity/identity_asset_lock_proof_locked_transaction_mismatch_error.rs

@@ -2,6 +2,7 @@ use dpp::consensus::basic::identity::IdentityAssetLockProofLockedTransactionMism
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
 use dpp::dashcore::hashes::Hash;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -24,13 +25,13 @@ impl IdentityAssetLockProofLockedTransactionMismatchErrorWasm {
     #[wasm_bindgen(js_name=getInstantLockTransactionId)]
     pub fn instant_lock_transaction_id(&self) -> Buffer {
         let tx_id = self.inner.instant_lock_transaction_id();
-        Buffer::from_bytes(&tx_id)
+        Buffer::from_bytes(&tx_id.to_byte_array())
     }
 
     #[wasm_bindgen(js_name=getAssetLockTransactionId)]
     pub fn asset_lock_transaction_id(&self) -> Buffer {
         let tx_id = self.inner.asset_lock_transaction_id();
-        let mut hash_bytes = tx_id.as_hash().into_inner();
+        let mut hash_bytes = tx_id.to_byte_array();
         hash_bytes.reverse();
 
         Buffer::from_bytes(&hash_bytes)
@@ -45,13 +46,4 @@ impl IdentityAssetLockProofLockedTransactionMismatchErrorWasm {
     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/identity/identity_asset_lock_transaction_is_not_found_error.rs

@@ -1,6 +1,7 @@
 use dpp::consensus::basic::identity::IdentityAssetLockTransactionIsNotFoundError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -34,13 +35,4 @@ impl IdentityAssetLockTransactionIsNotFoundErrorWasm {
     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/identity/identity_asset_lock_transaction_out_point_already_exists_error.rs

@@ -2,6 +2,7 @@ use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutPointAlready
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
 use dpp::dashcore::hashes::Hash;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -29,7 +30,7 @@ impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
     #[wasm_bindgen(js_name=getTransactionId)]
     pub fn transaction_id(&self) -> Buffer {
         let tx_id = self.inner.transaction_id();
-        let mut tx_id_bytes = tx_id.as_hash().into_inner();
+        let mut tx_id_bytes = tx_id.to_byte_array();
         tx_id_bytes.reverse();
         Buffer::from_bytes(&tx_id_bytes)
     }
@@ -43,13 +44,4 @@ impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
     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/identity/identity_asset_lock_transaction_output_not_found_error.rs

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

@@ -1,7 +1,10 @@
 use crate::buffer::Buffer;
+use crate::identifier::IdentifierWrapper;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::IdentityInsufficientBalanceError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
+use std::ops::Deref;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityInsufficientBalanceError)]
@@ -18,8 +21,8 @@ impl From<&IdentityInsufficientBalanceError> for IdentityInsufficientBalanceErro
 #[wasm_bindgen(js_class=IdentityInsufficientBalanceError)]
 impl IdentityInsufficientBalanceErrorWasm {
     #[wasm_bindgen(js_name=getIdentityId)]
-    pub fn identity_id(&self) -> Buffer {
-        Buffer::from_bytes(self.inner.identity_id.as_bytes())
+    pub fn identity_id(&self) -> IdentifierWrapper {
+        (*self.inner.identity_id()).into()
     }
 
     #[wasm_bindgen(js_name=getBalance)]
@@ -36,13 +39,4 @@ impl IdentityInsufficientBalanceErrorWasm {
     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/identity/invalid_asset_lock_proof_core_chain_height_error.rs

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

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

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

@@ -23,7 +23,7 @@ impl InvalidIdentityAssetLockProofChainLockValidationErrorWasm {
     #[wasm_bindgen(js_name=getTransactionId)]
     pub fn transaction_id(&self) -> Buffer {
         let tx_id = self.inner.transaction_id();
-        let mut tx_id_bytes = tx_id.as_hash().into_inner();
+        let mut tx_id_bytes = tx_id.to_byte_array();
         tx_id_bytes.reverse();
         Buffer::from_bytes(&tx_id_bytes)
     }

package/src/errors/consensus/basic/identity/invalid_identity_asset_lock_transaction_error.rs

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

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

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

@@ -1,6 +1,7 @@
 use dpp::consensus::basic::identity::InvalidIdentityCreditWithdrawalTransitionOutputScriptError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -29,13 +30,4 @@ impl InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm {
     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/identity/invalid_identity_credit_withdrawal_transition_pooling_error.rs

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

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

@@ -4,6 +4,7 @@ use dpp::errors::consensus::codes::ErrorWithCode;
 use crate::buffer::Buffer;
 use dpp::consensus::ConsensusError;
 use dpp::errors::consensus::ConsensusError as DPPConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidIdentityPublicKeyDataError)]
@@ -39,13 +40,4 @@ impl InvalidIdentityPublicKeyDataErrorWasm {
     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/identity/invalid_identity_public_key_security_level_error.rs

@@ -4,6 +4,7 @@ use dpp::errors::consensus::codes::ErrorWithCode;
 use crate::buffer::Buffer;
 use dpp::consensus::ConsensusError;
 use dpp::errors::consensus::ConsensusError as DPPConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidIdentityPublicKeySecurityLevelError)]
@@ -46,13 +47,4 @@ impl InvalidIdentityPublicKeySecurityLevelErrorWasm {
     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/identity/invalid_identity_public_key_type_error.rs

@@ -6,6 +6,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::InvalidIdentityPublicKeyTypeError;
 use dpp::consensus::ConsensusError;
 use dpp::identity::KeyType;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidIdentityPublicKeyTypeError)]
@@ -44,13 +45,4 @@ impl InvalidIdentityPublicKeyTypeErrorWasm {
     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/identity/invalid_instant_asset_lock_proof_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::identity::InvalidInstantAssetLockProofError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidInstantAssetLockProofError)]
@@ -26,13 +27,4 @@ impl InvalidInstantAssetLockProofErrorWasm {
     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/identity/invalid_instant_asset_lock_proof_signature_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::identity::InvalidInstantAssetLockProofSignatureError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidInstantAssetLockProofSignatureError)]
@@ -28,13 +29,4 @@ impl InvalidInstantAssetLockProofSignatureErrorWasm {
     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/identity/missing_master_public_key_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::identity::MissingMasterPublicKeyError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=MissingMasterPublicKeyError)]
@@ -26,13 +27,4 @@ impl MissingMasterPublicKeyErrorWasm {
     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/identity/missing_public_key_error.rs

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

@@ -3,6 +3,7 @@ use dpp::consensus::basic::IncompatibleProtocolVersionError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
 
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IncompatibleProtocolVersionError)]
@@ -37,13 +38,4 @@ impl IncompatibleProtocolVersionErrorWasm {
     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/invalid_identifier_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::invalid_identifier_error::InvalidIdentifierError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidIdentifierError)]
@@ -36,13 +37,4 @@ impl InvalidIdentifierErrorWasm {
     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/invalid_signature_public_key_security_level_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::InvalidSignaturePublicKeySecurityLevelError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidSignaturePublicKeySecurityLevelError)]
@@ -25,12 +26,12 @@ impl InvalidSignaturePublicKeySecurityLevelErrorWasm {
     }
 
     #[wasm_bindgen(js_name=getKeySecurityLevelRequirement)]
-    pub fn get_allowed_key_security_levels(&self) -> Vec<u8> {
-        self.inner
-            .allowed_key_security_levels()
-            .iter()
-            .map(|security_level| *security_level as u8)
-            .collect()
+    pub fn get_allowed_key_security_levels(&self) -> js_sys::Array {
+        let array = js_sys::Array::new();
+        for security_level in self.inner.allowed_key_security_levels() {
+            array.push(&JsValue::from(security_level as u32));
+        }
+        array
     }
 
     #[wasm_bindgen(js_name=getCode)]
@@ -42,13 +43,4 @@ impl InvalidSignaturePublicKeySecurityLevelErrorWasm {
     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/invalid_state_transition_signature_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::InvalidStateTransitionSignatureError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidStateTransitionSignatureError)]
@@ -26,13 +27,4 @@ impl InvalidStateTransitionSignatureErrorWasm {
     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/json_schema_compilation_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::json_schema_compilation_error::JsonSchemaCompilationError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=JsonSchemaCompilationError)]
@@ -31,13 +32,4 @@ impl JsonSchemaCompilationErrorWasm {
     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()))
-    }
 }