@dashevo/wasm-dpp 0.24.0-dev.30 → 0.25.0-dev.1

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

@@ -31,7 +31,7 @@ impl InvalidStateTransitionSignatureErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -36,7 +36,7 @@ impl JsonSchemaCompilationErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -5,8 +5,6 @@ use dpp::errors::consensus::codes::ErrorWithCode;
 
 use dpp::errors::consensus::ConsensusError;
 
-use serde_json::Value;
-
 use crate::buffer::Buffer;
 use wasm_bindgen::prelude::*;
 
@@ -70,7 +68,7 @@ impl JsonSchemaErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -37,7 +37,7 @@ impl PublicKeyIsDisabledErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -3,7 +3,7 @@ use crate::Serialize;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::signature::PublicKeySecurityLevelNotMetError;
 use dpp::consensus::ConsensusError;
-use dpp::identity::SecurityLevel;
+
 use wasm_bindgen::prelude::*;
 
 #[derive(Serialize)]
@@ -44,7 +44,7 @@ impl PublicKeySecurityLevelNotMetErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -43,7 +43,7 @@ impl InvalidStateTransitionTypeErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -38,7 +38,7 @@ impl MissingStateTransitionTypeErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .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

@@ -41,7 +41,7 @@ impl StateTransitionMaxSizeExceededErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -41,7 +41,7 @@ impl UnsupportedProtocolVersionErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -41,7 +41,7 @@ impl WrongPublicKeyPurposeErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/consensus_error.rs

@@ -13,6 +13,7 @@ use crate::errors::consensus::basic::identity::{
     IdentityAssetLockTransactionOutputNotFoundErrorWasm, IdentityInsufficientBalanceErrorWasm,
     InvalidAssetLockProofCoreChainHeightErrorWasm, InvalidAssetLockProofTransactionHeightErrorWasm,
     InvalidAssetLockTransactionOutputReturnSizeErrorWasm,
+    InvalidIdentityAssetLockProofChainLockValidationErrorWasm,
     InvalidIdentityAssetLockTransactionErrorWasm,
     InvalidIdentityAssetLockTransactionOutputErrorWasm,
     InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm,
@@ -24,6 +25,7 @@ use crate::errors::consensus::basic::identity::{
 };
 use crate::errors::consensus::state::identity::{
     DuplicatedIdentityPublicKeyIdStateErrorWasm, DuplicatedIdentityPublicKeyStateErrorWasm,
+    MissingIdentityPublicKeyIdsErrorWasm,
 };
 use dpp::consensus::basic::BasicError;
 use dpp::consensus::basic::BasicError::{
@@ -34,6 +36,7 @@ use dpp::consensus::basic::BasicError::{
     IdentityAssetLockTransactionOutputNotFoundError, IncompatibleProtocolVersionError,
     IncompatibleRe2PatternError, InvalidAssetLockProofCoreChainHeightError,
     InvalidAssetLockProofTransactionHeightError, InvalidAssetLockTransactionOutputReturnSizeError,
+    InvalidIdentityAssetLockProofChainLockValidationError,
     InvalidIdentityAssetLockTransactionError, InvalidIdentityAssetLockTransactionOutputError,
     InvalidIdentityCreditWithdrawalTransitionCoreFeeError,
     InvalidIdentityCreditWithdrawalTransitionOutputScriptError, InvalidIdentityPublicKeyDataError,
@@ -44,10 +47,11 @@ use dpp::consensus::basic::BasicError::{
 };
 use dpp::consensus::fee::fee_error::FeeError;
 use dpp::consensus::signature::SignatureError;
+
 use dpp::consensus::state::data_trigger::data_trigger_error::DataTriggerError;
 use dpp::consensus::state::state_error::StateError;
-use dpp::errors::consensus::codes::ErrorWithCode;
-use wasm_bindgen::JsValue;
+
+use wasm_bindgen::{JsError, JsValue};
 
 use crate::errors::consensus::basic::data_contract::{
     DataContractHaveNewUniqueIndexErrorWasm, DataContractImmutablePropertiesUpdateErrorWasm,
@@ -63,7 +67,10 @@ use crate::errors::consensus::basic::state_transition::{
     InvalidStateTransitionTypeErrorWasm, MissingStateTransitionTypeErrorWasm,
     StateTransitionMaxSizeExceededErrorWasm,
 };
-use crate::errors::consensus::signature::IdentityNotFoundErrorWasm;
+use crate::errors::consensus::signature::{
+    BasicBLSErrorWasm, BasicECDSAErrorWasm, IdentityNotFoundErrorWasm,
+    SignatureShouldNotBePresentErrorWasm,
+};
 use crate::errors::consensus::state::data_contract::data_trigger::{
     DataTriggerConditionErrorWasm, DataTriggerExecutionErrorWasm,
 };
@@ -79,7 +86,6 @@ use crate::errors::consensus::state::identity::{
     InvalidIdentityPublicKeyIdErrorWasm, InvalidIdentityRevisionErrorWasm,
     MaxIdentityPublicKeyLimitReachedErrorWasm,
 };
-use crate::errors::value_error::PlatformValueErrorWasm;
 
 use crate::errors::consensus::basic::data_contract::{
     DataContractMaxDepthExceedErrorWasm, DuplicateIndexErrorWasm, DuplicateIndexNameErrorWasm,
@@ -117,6 +123,7 @@ pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue {
         DPPConsensusError::SignatureError(e) => from_signature_error(e),
         DPPConsensusError::StateError(state_error) => from_state_error(state_error),
         DPPConsensusError::BasicError(basic_error) => from_basic_error(basic_error),
+        DPPConsensusError::DefaultError => JsError::new("DefaultError").into(),
     }
 }
 
@@ -166,6 +173,9 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::IdentityPublicKeyIsDisabledError(e) => {
             IdentityPublicKeyIsDisabledErrorWasm::from(e).into()
         }
+        StateError::MissingIdentityPublicKeyIdsError(e) => {
+            MissingIdentityPublicKeyIdsErrorWasm::from(e).into()
+        }
         StateError::DataTriggerError(data_trigger_error) => match data_trigger_error.deref() {
             DataTriggerError::DataTriggerConditionError(e) => {
                 DataTriggerConditionErrorWasm::from(e).into()
@@ -177,6 +187,8 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
                 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(),
         StateError::IdentityAlreadyExistsError(e) => {
             let wasm_error: IdentityAlreadyExistsErrorWasm = e.into();
             wasm_error.into()
@@ -323,6 +335,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         InvalidInstantAssetLockProofSignatureError(e) => {
             InvalidInstantAssetLockProofSignatureErrorWasm::from(e).into()
         }
+        InvalidIdentityAssetLockProofChainLockValidationError(e) => {
+            InvalidIdentityAssetLockProofChainLockValidationErrorWasm::from(e).into()
+        }
         IdentityAssetLockProofLockedTransactionMismatchError(e) => {
             IdentityAssetLockProofLockedTransactionMismatchErrorWasm::from(e).into()
         }
@@ -370,6 +385,11 @@ fn from_signature_error(signature_error: &SignatureError) -> JsValue {
         SignatureError::WrongPublicKeyPurposeError(err) => {
             WrongPublicKeyPurposeErrorWasm::from(err).into()
         }
+        SignatureError::SignatureShouldNotBePresentError(err) => {
+            SignatureShouldNotBePresentErrorWasm::from(err).into()
+        }
+        SignatureError::BasicECDSAError(err) => BasicECDSAErrorWasm::from(err).into(),
+        SignatureError::BasicBLSError(err) => BasicBLSErrorWasm::from(err).into(),
     }
 }
 

package/src/errors/consensus/deserialize.rs

@@ -6,6 +6,6 @@ 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())
-        .and_then(|consensus_error| Ok(from_consensus_error(consensus_error)))
+        .map(from_consensus_error)
         .map_err(|e| e.into())
 }

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

@@ -49,7 +49,7 @@ impl BalanceIsNotEnoughErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -0,0 +1,38 @@
+use crate::buffer::Buffer;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::signature::BasicBLSError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=BasicBLSError)]
+pub struct BasicBLSErrorWasm {
+    inner: BasicBLSError,
+}
+
+impl From<&BasicBLSError> for BasicBLSErrorWasm {
+    fn from(e: &BasicBLSError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=BasicBLSError)]
+impl BasicBLSErrorWasm {
+    #[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()
+    }
+
+    #[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

@@ -0,0 +1,38 @@
+use crate::buffer::Buffer;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::signature::BasicECDSAError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=BasicECDSAError)]
+pub struct BasicECDSAErrorWasm {
+    inner: BasicECDSAError,
+}
+
+impl From<&BasicECDSAError> for BasicECDSAErrorWasm {
+    fn from(e: &BasicECDSAError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=BasicECDSAError)]
+impl BasicECDSAErrorWasm {
+    #[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()
+    }
+
+    #[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/mod.rs

@@ -1,3 +1,9 @@
+mod basic_bls_error;
+mod basic_ecdsa_error;
 mod identity_not_found_error;
+mod signature_should_not_be_present_error;
 
+pub use basic_bls_error::*;
+pub use basic_ecdsa_error::*;
 pub use identity_not_found_error::*;
+pub use signature_should_not_be_present_error::*;

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

@@ -0,0 +1,38 @@
+use crate::buffer::Buffer;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::signature::SignatureShouldNotBePresentError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=SignatureShouldNotBePresentError)]
+pub struct SignatureShouldNotBePresentErrorWasm {
+    inner: SignatureShouldNotBePresentError,
+}
+
+impl From<&SignatureShouldNotBePresentError> for SignatureShouldNotBePresentErrorWasm {
+    fn from(e: &SignatureShouldNotBePresentError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=SignatureShouldNotBePresentError)]
+impl SignatureShouldNotBePresentErrorWasm {
+    #[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()
+    }
+
+    #[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

@@ -3,7 +3,7 @@ use crate::identifier::IdentifierWrapper;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::data_contract::data_contract_already_present_error::DataContractAlreadyPresentError;
 use dpp::consensus::ConsensusError;
-use dpp::identifier::Identifier;
+
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataContractAlreadyPresentError)]
@@ -45,7 +45,7 @@ impl DataContractAlreadyPresentErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .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

@@ -3,6 +3,7 @@ use crate::buffer::Buffer;
 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 wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerConditionError)]
@@ -47,8 +48,64 @@ impl DataTriggerConditionErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }
 }
+
+#[wasm_bindgen(js_name=DataTriggerActionConditionError)]
+pub struct DataTriggerActionConditionErrorWasm {
+    data_contract_id: Identifier,
+    document_transition_id: Identifier,
+    message: String,
+    owner_id: Option<Identifier>,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DataTriggerActionConditionError)]
+impl DataTriggerActionConditionErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> Buffer {
+        Buffer::from_bytes(self.data_contract_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTransitionId)]
+    pub fn document_transition_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_transition_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn message(&self) -> String {
+        self.message.clone()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn owner_id(&self) -> Option<Buffer> {
+        let owner_id = self.owner_id.as_ref()?;
+        Some(Buffer::from_bytes(owner_id.as_bytes()))
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DataTriggerActionConditionErrorWasm {
+    pub fn new(
+        data_contract_id: Identifier,
+        document_transition_id: Identifier,
+        message: String,
+        owner_id: Option<Identifier>,
+        code: u32,
+    ) -> Self {
+        Self {
+            data_contract_id,
+            document_transition_id,
+            message,
+            owner_id,
+            code,
+        }
+    }
+}

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

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 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 wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerExecutionError)]
@@ -46,8 +47,72 @@ impl DataTriggerExecutionErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }
 }
+
+#[wasm_bindgen(js_name=DataTriggerActionExecutionError)]
+pub struct DataTriggerActionExecutionErrorWasm {
+    data_contract_id: Identifier,
+    document_transition_id: Identifier,
+    message: String,
+    execution_error: JsError,
+    owner_id: Option<Identifier>,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DataTriggerActionExecutionError)]
+impl DataTriggerActionExecutionErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> Buffer {
+        Buffer::from_bytes(self.data_contract_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getExecutionError)]
+    pub fn data_execution_error(&self) -> JsError {
+        self.execution_error.clone()
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTransitionId)]
+    pub fn document_transition_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_transition_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn message(&self) -> String {
+        self.message.clone()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn owner_id(&self) -> Option<Buffer> {
+        let owner_id = self.owner_id.as_ref()?;
+        Some(Buffer::from_bytes(owner_id.as_bytes()))
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DataTriggerActionExecutionErrorWasm {
+    pub fn new(
+        data_contract_id: Identifier,
+        document_transition_id: Identifier,
+        message: String,
+        execution_error: wasm_bindgen::JsError,
+        owner_id: Option<Identifier>,
+        code: u32,
+    ) -> Self {
+        Self {
+            data_contract_id,
+            document_transition_id,
+            message,
+            execution_error,
+            owner_id,
+            code,
+        }
+    }
+}

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

@@ -3,6 +3,7 @@ use crate::buffer::Buffer;
 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 wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerInvalidResultError)]
@@ -42,8 +43,56 @@ impl DataTriggerInvalidResultErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }
 }
+
+#[wasm_bindgen(js_name=DataTriggerActionInvalidResultError)]
+pub struct DataTriggerActionInvalidResultErrorWasm {
+    data_contract_id: Identifier,
+    document_transition_id: Identifier,
+    owner_id: Option<Identifier>,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DataTriggerActionInvalidResultError)]
+impl DataTriggerActionInvalidResultErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> Buffer {
+        Buffer::from_bytes(self.data_contract_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTransitionId)]
+    pub fn document_transition_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_transition_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn owner_id(&self) -> Option<Buffer> {
+        let owner_id = self.owner_id.as_ref()?;
+        Some(Buffer::from_bytes(owner_id.as_bytes()))
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DataTriggerActionInvalidResultErrorWasm {
+    pub fn new(
+        data_contract_id: Identifier,
+        document_transition_id: Identifier,
+        owner_id: Option<Identifier>,
+        code: u32,
+    ) -> Self {
+        Self {
+            data_contract_id,
+            document_transition_id,
+            owner_id,
+            code,
+        }
+    }
+}

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

@@ -36,7 +36,7 @@ impl DocumentAlreadyPresentErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -36,7 +36,7 @@ impl DocumentNotFoundErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -46,7 +46,7 @@ impl DocumentOwnerIdMismatchErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -24,7 +24,7 @@ impl DocumentTimestampWindowViolationErrorWasm {
 
     #[wasm_bindgen(js_name=getTimestampName)]
     pub fn timestamp_name(&self) -> String {
-        self.inner.timestamp_name().to_string()
+        self.inner.timestamp_name()
     }
 
     #[wasm_bindgen(js_name=getTimestamp)]
@@ -62,7 +62,7 @@ impl DocumentTimestampWindowViolationErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

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

@@ -35,7 +35,7 @@ impl DocumentTimestampsMismatchErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }