@dashevo/wasm-dpp 0.24.0-dev.33 → 0.25.0-dev.10

package/src/errors/consensus/basic/data_contract/data_contract_max_depth_exceed_error.rs

@@ -41,7 +41,7 @@ impl DataContractMaxDepthExceedErrorWasm {
     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/data_contract/data_contract_unique_indices_changed_error.rs

@@ -41,7 +41,7 @@ impl DataContractUniqueIndicesChangedErrorWasm {
     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/data_contract/duplicate_index_name_error.rs

@@ -19,12 +19,12 @@ impl From<&DuplicateIndexNameError> for DuplicateIndexNameErrorWasm {
 impl DuplicateIndexNameErrorWasm {
     #[wasm_bindgen(js_name=getDocumentType)]
     pub fn get_document_type(&self) -> String {
-        self.inner.document_type().to_string()
+        self.inner.document_type()
     }
 
     #[wasm_bindgen(js_name=getDuplicateIndexName)]
     pub fn get_duplicate_index_name(&self) -> String {
-        self.inner.duplicate_index_name().to_string()
+        self.inner.duplicate_index_name()
     }
 
     #[wasm_bindgen(js_name=getCode)]
@@ -41,7 +41,7 @@ impl DuplicateIndexNameErrorWasm {
     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/data_contract/incompatible_data_contract_schema_error.rs

@@ -24,12 +24,12 @@ impl IncompatibleDataContractSchemaErrorWasm {
 
     #[wasm_bindgen(js_name=getOperation)]
     pub fn get_operation(&self) -> String {
-        self.inner.operation().to_string()
+        self.inner.operation()
     }
 
     #[wasm_bindgen(js_name=getFieldPath)]
     pub fn get_field_path(&self) -> String {
-        self.inner.field_path().to_string()
+        self.inner.field_path()
     }
 
     #[wasm_bindgen(js_name=getCode)]
@@ -46,7 +46,7 @@ impl IncompatibleDataContractSchemaErrorWasm {
     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/data_contract/incompatible_re2_pattern_error.rs

@@ -19,17 +19,17 @@ impl From<&IncompatibleRe2PatternError> for IncompatibleRe2PatternErrorWasm {
 impl IncompatibleRe2PatternErrorWasm {
     #[wasm_bindgen(js_name=getPattern)]
     pub fn get_pattern(&self) -> String {
-        self.inner.pattern().to_string()
+        self.inner.pattern()
     }
 
     #[wasm_bindgen(js_name=getPath)]
     pub fn get_path(&self) -> String {
-        self.inner.path().to_string()
+        self.inner.path()
     }
 
     #[wasm_bindgen(js_name=getMessage)]
     pub fn get_message(&self) -> String {
-        self.inner.message().clone()
+        self.inner.message()
     }
 
     #[wasm_bindgen(js_name=getCode)]
@@ -46,7 +46,7 @@ impl IncompatibleRe2PatternErrorWasm {
     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/data_contract/index_error/duplicate_index_error.rs

@@ -41,7 +41,7 @@ impl DuplicateIndexErrorWasm {
     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/data_contract/index_error/invalid_compound_index_error.rs

@@ -41,7 +41,7 @@ impl InvalidCompoundIndexErrorWasm {
     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/data_contract/index_error/invalid_index_property_type_error.rs

@@ -51,7 +51,7 @@ impl InvalidIndexPropertyTypeErrorWasm {
     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/data_contract/index_error/invalid_indexed_property_constraint_error.rs

@@ -56,7 +56,7 @@ impl InvalidIndexedPropertyConstraintErrorWasm {
     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/data_contract/index_error/system_property_index_already_present_error.rs

@@ -46,7 +46,7 @@ impl SystemPropertyIndexAlreadyPresentErrorWasm {
     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/data_contract/index_error/undefined_index_property_error.rs

@@ -46,7 +46,7 @@ impl UndefinedIndexPropertyErrorWasm {
     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/data_contract/index_error/unique_indices_limit_reached_error.rs

@@ -41,7 +41,7 @@ impl UniqueIndicesLimitReachedErrorWasm {
     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/data_contract/invalid_data_contract_id_error.rs

@@ -41,7 +41,7 @@ impl InvalidDataContractIdErrorWasm {
     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/data_contract/invalid_data_contract_version_error.rs

@@ -41,7 +41,7 @@ impl InvalidDataContractVersionErrorWasm {
     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/data_contract/invalid_json_schema_ref_error.rs

@@ -19,7 +19,7 @@ impl From<&InvalidJsonSchemaRefError> for InvalidJsonSchemaRefErrorWasm {
 impl InvalidJsonSchemaRefErrorWasm {
     #[wasm_bindgen(js_name=getRefError)]
     pub fn get_ref_error(&self) -> String {
-        self.inner.message().to_string()
+        self.inner.message()
     }
 
     #[wasm_bindgen(js_name=getCode)]
@@ -36,7 +36,7 @@ impl InvalidJsonSchemaRefErrorWasm {
     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/decode/protocol_version_parsing_error.rs

@@ -38,7 +38,7 @@ impl ProtocolVersionParsingErrorWasm {
     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/decode/serialized_object_parsing_error.rs

@@ -36,7 +36,7 @@ impl SerializedObjectParsingErrorWasm {
     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/document/data_contract_not_present_error.rs

@@ -37,7 +37,7 @@ impl DataContractNotPresentErrorWasm {
     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/document/duplicate_document_transitions_with_ids_error.rs

@@ -48,7 +48,7 @@ impl DuplicateDocumentTransitionsWithIdsErrorWasm {
     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/document/duplicate_document_transitions_with_indices_error.rs

@@ -48,7 +48,7 @@ impl DuplicateDocumentTransitionsWithIndicesErrorWasm {
     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/document/inconsistent_compound_index_data_error.rs

@@ -29,7 +29,7 @@ impl InconsistentCompoundIndexDataErrorWasm {
 
     #[wasm_bindgen(js_name=getDocumentType)]
     pub fn get_document_type(&self) -> String {
-        self.inner.document_type().to_string()
+        self.inner.document_type()
     }
 
     #[wasm_bindgen(js_name=getCode)]
@@ -46,7 +46,7 @@ impl InconsistentCompoundIndexDataErrorWasm {
     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/document/invalid_document_transition_action_error.rs

@@ -36,7 +36,7 @@ impl InvalidDocumentTransitionActionErrorWasm {
     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/document/invalid_document_transition_id_error.rs

@@ -41,7 +41,7 @@ impl InvalidDocumentTransitionIdErrorWasm {
     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/document/invalid_document_type_error.rs

@@ -20,7 +20,7 @@ impl From<&InvalidDocumentTypeError> for InvalidDocumentTypeErrorWasm {
 impl InvalidDocumentTypeErrorWasm {
     #[wasm_bindgen(js_name=getType)]
     pub fn get_document_type(&self) -> String {
-        self.inner.document_type().to_string()
+        self.inner.document_type()
     }
 
     #[wasm_bindgen(js_name=getDataContractId)]
@@ -42,7 +42,7 @@ impl InvalidDocumentTypeErrorWasm {
     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/document/missing_data_contract_id_error.rs

@@ -32,7 +32,7 @@ impl MissingDataContractIdErrorWasm {
     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/document/missing_document_transition_action_error.rs

@@ -31,7 +31,7 @@ impl MissingDocumentTransitionActionErrorWasm {
     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/document/missing_document_transition_type_error.rs

@@ -31,7 +31,7 @@ impl MissingDocumentTransitionTypeErrorWasm {
     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/document/missing_document_type_error.rs

@@ -31,7 +31,7 @@ impl MissingDocumentTypeErrorWasm {
     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/identity/duplicated_identity_public_key_error.rs

@@ -41,7 +41,7 @@ impl DuplicatedIdentityPublicKeyErrorWasm {
     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/identity/duplicated_identity_public_key_id_error.rs

@@ -41,7 +41,7 @@ impl DuplicatedIdentityPublicKeyIdErrorWasm {
     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/identity/identity_asset_lock_proof_locked_transaction_mismatch_error.rs

@@ -50,7 +50,7 @@ impl IdentityAssetLockProofLockedTransactionMismatchErrorWasm {
     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/identity/identity_asset_lock_transaction_is_not_found_error.rs

@@ -39,7 +39,7 @@ impl IdentityAssetLockTransactionIsNotFoundErrorWasm {
     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/identity/identity_asset_lock_transaction_out_point_already_exists_error.rs

@@ -48,7 +48,7 @@ impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
     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/identity/identity_asset_lock_transaction_output_not_found_error.rs

@@ -38,7 +38,7 @@ impl IdentityAssetLockTransactionOutputNotFoundErrorWasm {
     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/identity/identity_insufficient_balance_error.rs

@@ -41,7 +41,7 @@ impl IdentityInsufficientBalanceErrorWasm {
     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/identity/invalid_asset_lock_proof_core_chain_height_error.rs

@@ -43,7 +43,7 @@ impl InvalidAssetLockProofCoreChainHeightErrorWasm {
     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/identity/invalid_asset_lock_proof_transaction_height_error.rs

@@ -43,7 +43,7 @@ impl InvalidAssetLockProofTransactionHeightErrorWasm {
     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/identity/invalid_asset_lock_transaction_output_return_size_error.rs

@@ -38,7 +38,7 @@ impl InvalidAssetLockTransactionOutputReturnSizeErrorWasm {
     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/identity/invalid_identity_asset_lock_proof_chain_lock_validation_error.rs

@@ -0,0 +1,35 @@
+use dpp::consensus::basic::identity::InvalidIdentityAssetLockProofChainLockValidationError;
+
+use crate::buffer::Buffer;
+
+use dpp::dashcore::hashes::Hash;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidIdentityAssetLockProofChainLockValidationErrorWasm)]
+pub struct InvalidIdentityAssetLockProofChainLockValidationErrorWasm {
+    inner: InvalidIdentityAssetLockProofChainLockValidationError,
+}
+
+impl From<&InvalidIdentityAssetLockProofChainLockValidationError>
+    for InvalidIdentityAssetLockProofChainLockValidationErrorWasm
+{
+    fn from(e: &InvalidIdentityAssetLockProofChainLockValidationError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentityAssetLockProofChainLockValidationErrorWasm)]
+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();
+        tx_id_bytes.reverse();
+        Buffer::from_bytes(&tx_id_bytes)
+    }
+
+    #[wasm_bindgen(js_name=getHeightReportedNotLocked)]
+    pub fn get_height_reported_not_locked(&self) -> u32 {
+        self.inner.height_reported_not_locked()
+    }
+}

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

@@ -38,7 +38,7 @@ impl InvalidIdentityAssetLockTransactionErrorWasm {
     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/identity/invalid_identity_asset_lock_transaction_output_error.rs

@@ -38,7 +38,7 @@ impl InvalidIdentityAssetLockTransactionOutputErrorWasm {
     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/identity/invalid_identity_credit_withdrawal_transition_core_fee_error.rs

@@ -38,7 +38,7 @@ impl InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm {
     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/identity/invalid_identity_credit_withdrawal_transition_output_script_error.rs

@@ -34,7 +34,7 @@ impl InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm {
     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/identity/invalid_identity_credit_withdrawal_transition_pooling_error.rs

@@ -38,7 +38,7 @@ impl NotImplementedIdentityCreditWithdrawalTransitionPoolingErrorWasm {
     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/identity/invalid_identity_key_signature_error.rs

@@ -37,7 +37,7 @@ impl InvalidIdentityKeySignatureErrorWasm {
     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/identity/invalid_identity_public_key_data_error.rs

@@ -44,7 +44,7 @@ impl InvalidIdentityPublicKeyDataErrorWasm {
     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/identity/invalid_identity_public_key_security_level_error.rs

@@ -51,7 +51,7 @@ impl InvalidIdentityPublicKeySecurityLevelErrorWasm {
     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/identity/invalid_identity_public_key_type_error.rs

@@ -49,7 +49,7 @@ impl InvalidIdentityPublicKeyTypeErrorWasm {
     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/identity/invalid_instant_asset_lock_proof_error.rs

@@ -31,7 +31,7 @@ impl InvalidInstantAssetLockProofErrorWasm {
     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/identity/invalid_instant_asset_lock_proof_signature_error.rs

@@ -33,7 +33,7 @@ impl InvalidInstantAssetLockProofSignatureErrorWasm {
     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/identity/missing_master_public_key_error.rs

@@ -31,7 +31,7 @@ impl MissingMasterPublicKeyErrorWasm {
     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/identity/missing_public_key_error.rs

@@ -37,7 +37,7 @@ impl MissingPublicKeyErrorWasm {
     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()))
     }