@dashevo/wasm-dpp 0.25.6 → 0.25.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.25.6",
+  "version": "0.25.9",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,10 +43,8 @@
     "@babel/cli": "^7.21.0",
     "@babel/core": "^7.15.5",
     "@babel/preset-env": "^7.15.4",
-    "@dashevo/dashcore-lib": "~0.20.9",
-    "@dashevo/dpns-contract": "0.25.6",
-    "@dashevo/dpp": "0.25.6",
-    "@dashevo/wasm-re2": "~2.0.4",
+    "@dashevo/dashcore-lib": "~0.21.0",
+    "@dashevo/dpns-contract": "0.25.9",
     "@types/bs58": "^4.0.1",
     "@types/node": "^14.6.0",
     "@yarnpkg/pnpify": "^4.0.0-rc.42",

package/src/dash_platform_protocol.rs

@@ -79,11 +79,11 @@ impl DashPlatformProtocolWasm {
     pub fn state_transition(&self) -> StateTransitionFactoryWasm {
         self.protocol.state_transition().into()
     }
-    //
-    // #[wasm_bindgen(getter = protocolVersion)]
-    // pub fn protocol_version(&self) -> u32 {
-    //     self.protocol_version
-    // }
+
+    #[wasm_bindgen(getter = protocolVersion)]
+    pub fn protocol_version(&self) -> u32 {
+        self.protocol.protocol_version
+    }
     //
     // #[wasm_bindgen(js_name = getProtocolVersion)]
     // pub fn get_protocol_version(&self) -> u32 {

package/src/document/errors/invalid_document_error.rs

@@ -30,4 +30,9 @@ impl InvalidDocumentError {
     pub fn get_document(&self) -> JsValue {
         self.raw_document.clone()
     }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn get_message(&self) -> String {
+        self.to_string()
+    }
 }

package/src/document/extended_document.rs

@@ -27,6 +27,7 @@ use crate::identifier::{identifier_from_js_value, IdentifierWrapper};
 use crate::lodash::lodash_set;
 use crate::metadata::MetadataWasm;
 use crate::utils::{with_serde_to_platform_value, IntoWasm, ToSerdeJSONExt, WithJsError};
+use crate::validation::ValidationResultWasm;
 use crate::with_js_error;
 
 #[wasm_bindgen(js_name=ExtendedDocument)]
@@ -345,6 +346,20 @@ impl ExtendedDocumentWasm {
     pub fn deep_clone(&self) -> Self {
         self.clone()
     }
+
+    #[wasm_bindgen]
+    pub fn validate(&self, platform_version: u32) -> Result<ValidationResultWasm, JsValue> {
+        let platform_version =
+            PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
+
+        let result = self
+            .0
+            .validate(platform_version)
+            .with_js_error()?
+            .map(|_| JsValue::undefined());
+
+        Ok(result.into())
+    }
 }
 
 impl ExtendedDocumentWasm {

package/src/document/state_transition/document_batch_transition/document_transition/document_create_transition.rs

@@ -59,226 +59,231 @@ impl From<DocumentCreateTransitionWasm> for DocumentCreateTransition {
 
 #[wasm_bindgen(js_class=DocumentCreateTransition)]
 impl DocumentCreateTransitionWasm {
-    #[wasm_bindgen(constructor)]
-    pub fn from_object(
-        raw_object: JsValue,
-        data_contract: &DataContractWasm,
-    ) -> Result<DocumentCreateTransitionWasm, JsValue> {
-        let data_contract: DataContract = data_contract.clone().into();
-        let mut value = raw_object.with_serde_to_platform_value_map()?;
-        // let document_type = value
-        //     .get_string(dpp::document::extended_document::property_names::DOCUMENT_TYPE_NAME)
-        //     .map_err(ProtocolError::ValueError)
-        //     .with_js_error()?;
-        //
-        // let (identifier_paths, _): (Vec<_>, Vec<_>) = data_contract
-        //     .get_identifiers_and_binary_paths_owned(document_type.as_str())
-        //     .with_js_error()?;
-        // value
-        //     .replace_at_paths(identifier_paths, ReplacementType::Identifier)
-        //     .map_err(ProtocolError::ValueError)
-        //     .with_js_error()?;
-        let transition =
-            DocumentCreateTransition::from_value_map(value, data_contract).with_js_error()?;
-
-        Ok(transition.into())
-    }
-
-    // DocumentCreateTransition
-    #[wasm_bindgen(js_name=getEntropy)]
-    pub fn entropy(&self) -> Vec<u8> {
-        self.inner.entropy().to_vec()
-    }
-
-    #[wasm_bindgen(js_name=getCreatedAt)]
-    pub fn created_at(&self) -> Option<js_sys::Date> {
-        self.inner
-            .created_at()
-            .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64)))
-    }
-
-    #[wasm_bindgen(js_name=getUpdatedAt)]
-    pub fn updated_at(&self) -> Option<js_sys::Date> {
-        self.inner
-            .updated_at()
-            .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64)))
-    }
+    // #[wasm_bindgen(constructor)]
+    // pub fn from_object(
+    //     raw_object: JsValue,
+    //     data_contract: &DataContractWasm,
+    // ) -> Result<DocumentCreateTransitionWasm, JsValue> {
+    //     let data_contract: DataContract = data_contract.clone().into();
+    //     let mut value = raw_object.with_serde_to_platform_value_map()?;
+    //     // let document_type = value
+    //     //     .get_string(dpp::document::extended_document::property_names::DOCUMENT_TYPE_NAME)
+    //     //     .map_err(ProtocolError::ValueError)
+    //     //     .with_js_error()?;
+    //     //
+    //     // let (identifier_paths, _): (Vec<_>, Vec<_>) = data_contract
+    //     //     .get_identifiers_and_binary_paths_owned(document_type.as_str())
+    //     //     .with_js_error()?;
+    //     // value
+    //     //     .replace_at_paths(identifier_paths, ReplacementType::Identifier)
+    //     //     .map_err(ProtocolError::ValueError)
+    //     //     .with_js_error()?;
+    //     let transition =
+    //         DocumentCreateTransition::from_value_map(value, data_contract).with_js_error()?;
+    //
+    //     Ok(transition.into())
+    // }
+    //
+    // // DocumentCreateTransition
+    // #[wasm_bindgen(js_name=getEntropy)]
+    // pub fn entropy(&self) -> Vec<u8> {
+    //     self.inner.entropy().to_vec()
+    // }
+    //
+    // #[wasm_bindgen(js_name=getCreatedAt)]
+    // pub fn created_at(&self) -> Option<js_sys::Date> {
+    //     self.inner
+    //         .created_at()
+    //         .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64)))
+    // }
+    //
+    // #[wasm_bindgen(js_name=getUpdatedAt)]
+    // pub fn updated_at(&self) -> Option<js_sys::Date> {
+    //     self.inner
+    //         .updated_at()
+    //         .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64)))
+    // }
 
     #[wasm_bindgen(js_name=getRevision)]
     pub fn revision(&self) -> Revision {
         INITIAL_REVISION
     }
 
-    // AbstractDocumentTransitionMethods
-    #[wasm_bindgen(js_name=getId)]
-    pub fn id(&self) -> IdentifierWrapper {
-        self.inner.base().id().into()
-    }
-
-    #[wasm_bindgen(js_name=getType)]
-    pub fn document_type(&self) -> String {
-        self.inner.base().document_type_name().clone()
-    }
-
-    #[wasm_bindgen(js_name=getAction)]
-    pub fn action(&self) -> u8 {
-        DocumentTransitionActionType::Create as u8
-    }
-
-    #[wasm_bindgen(js_name=getDataContractId)]
-    pub fn data_contract_id(&self) -> IdentifierWrapper {
-        self.inner.base().data_contract_id().into()
-    }
-
-    #[wasm_bindgen]
-    pub fn get(&self, path: String, data_contract: &DataContractWasm) -> Result<JsValue, JsValue> {
-        let document_data = self.inner.data();
-
-        let value = if let Ok(value) = document_data.get_at_path(&path) {
-            value.clone()
-        } else {
-            return Ok(JsValue::undefined());
-        };
-
-        match self.get_binary_type_of_path(&path) {
-            BinaryType::Buffer => {
-                let bytes = value
-                    .to_bytes()
-                    .map_err(ProtocolError::ValueError)
-                    .with_js_error()?;
-                let buffer = Buffer::from_bytes(&bytes);
-                return Ok(buffer.into());
-            }
-            BinaryType::Identifier => {
-                let buffer = value
-                    .to_hash256()
-                    .map_err(ProtocolError::ValueError)
-                    .with_js_error()?;
-                let id = <IdentifierWrapper as convert::From<Identifier>>::from(Identifier::from(
-                    buffer,
-                ));
-                return Ok(id.into());
-            }
-            BinaryType::None => {
-                // Do nothing. If is 'None' it means that binary may contain binary data
-                // or may not captain it at all
-            }
-        }
-
-        let json_value: JsonValue = value
-            .clone()
-            .try_into()
-            .map_err(ProtocolError::ValueError)
-            .with_js_error()?;
-        let map = value
-            .to_btree_ref_string_map()
-            .map_err(ProtocolError::ValueError)
-            .with_js_error()?;
-        let js_value = json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?;
-
-        let document_type = data_contract
-            .inner()
-            .document_type_for_name(self.inner.base().document_type_name())
-            .with_js_error()?;
-        let identifier_paths = document_type.identifier_paths();
-        let binary_paths = document_type.binary_paths();
-
-        for property_path in identifier_paths {
-            if property_path.starts_with(&path) {
-                let (_, suffix) = property_path.split_at(path.len() + 1);
-
-                if let Some(bytes) = map
-                    .get_optional_bytes_at_path(suffix)
-                    .map_err(ProtocolError::ValueError)
-                    .with_js_error()?
-                {
-                    let id = <IdentifierWrapper as convert::From<Identifier>>::from(
-                        Identifier::from_bytes(&bytes).unwrap(),
-                    );
-                    lodash_set(&js_value, suffix, id.into());
-                }
-            }
-        }
-
-        for property_path in binary_paths {
-            if property_path.starts_with(&path) {
-                let (_, suffix) = property_path.split_at(path.len() + 1);
-
-                if let Some(bytes) = map
-                    .get_optional_bytes_at_path(suffix)
-                    .map_err(ProtocolError::ValueError)
-                    .with_js_error()?
-                {
-                    let buffer = Buffer::from_bytes(&bytes);
-                    lodash_set(&js_value, suffix, buffer.into());
-                }
-            }
-        }
-        Ok(js_value)
-    }
-
-    // DocumentTransitionObjectLike
-    #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self, options: &JsValue) -> Result<JsValue, JsValue> {
-        let (identifiers_paths, binary_paths) = self
-            .inner
-            .base()
-            .data_contract
-            .get_identifiers_and_binary_paths(&self.inner.base().document_type_name)
-            .with_js_error()?;
-
-        to_object(
-            self.inner.to_object().with_js_error()?,
-            options,
-            identifiers_paths
-                .into_iter()
-                .chain(document_create_transition::v0::IDENTIFIER_FIELDS),
-            binary_paths
-                .into_iter()
-                .chain(document_create_transition::v0::BINARY_FIELDS),
-        )
-    }
-
-    #[wasm_bindgen(js_name=toJSON)]
-    pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let value = self.inner.to_json().with_js_error()?;
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        let js_value = value.serialize(&serializer)?;
-        Ok(js_value)
+    #[wasm_bindgen(getter, js_name=INITIAL_REVISION)]
+    pub fn initial_revision() -> u32 {
+        INITIAL_REVISION as u32
     }
 
-    // AbstractDataDocumentTransition
-    #[wasm_bindgen(js_name=getData)]
-    pub fn get_data(&self) -> Result<JsValue, JsValue> {
-        let json_data = if let Some(ref data) = self.inner.data() {
-            data.to_json_value()
-                .map_err(ProtocolError::ValueError)
-                .with_js_error()?
-        } else {
-            return Ok(JsValue::undefined());
-        };
-
-        let js_value = json_data.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?;
-        Ok(js_value)
-    }
-}
-
-impl DocumentCreateTransitionWasm {
-    fn get_binary_type_of_path(&self, path: &String) -> BinaryType {
-        let maybe_binary_properties = self
-            .inner
-            .base
-            .data_contract
-            .get_binary_properties(&self.inner.base.document_type_name);
-
-        if let Ok(binary_properties) = maybe_binary_properties {
-            if let Some(data) = binary_properties.get(path) {
-                if data.is_type_of_identifier() {
-                    return BinaryType::Identifier;
-                }
-                return BinaryType::Buffer;
-            }
-        }
-        BinaryType::None
-    }
+    //     // AbstractDocumentTransitionMethods
+    //     #[wasm_bindgen(js_name=getId)]
+    //     pub fn id(&self) -> IdentifierWrapper {
+    //         self.inner.base().id().into()
+    //     }
+    //
+    //     #[wasm_bindgen(js_name=getType)]
+    //     pub fn document_type(&self) -> String {
+    //         self.inner.base().document_type_name().clone()
+    //     }
+    //
+    //     #[wasm_bindgen(js_name=getAction)]
+    //     pub fn action(&self) -> u8 {
+    //         DocumentTransitionActionType::Create as u8
+    //     }
+    //
+    //     #[wasm_bindgen(js_name=getDataContractId)]
+    //     pub fn data_contract_id(&self) -> IdentifierWrapper {
+    //         self.inner.base().data_contract_id().into()
+    //     }
+    //
+    //     #[wasm_bindgen]
+    //     pub fn get(&self, path: String, data_contract: &DataContractWasm) -> Result<JsValue, JsValue> {
+    //         let document_data = self.inner.data();
+    //
+    //         let value = if let Ok(value) = document_data.get_at_path(&path) {
+    //             value.clone()
+    //         } else {
+    //             return Ok(JsValue::undefined());
+    //         };
+    //
+    //         match self.get_binary_type_of_path(&path) {
+    //             BinaryType::Buffer => {
+    //                 let bytes = value
+    //                     .to_bytes()
+    //                     .map_err(ProtocolError::ValueError)
+    //                     .with_js_error()?;
+    //                 let buffer = Buffer::from_bytes(&bytes);
+    //                 return Ok(buffer.into());
+    //             }
+    //             BinaryType::Identifier => {
+    //                 let buffer = value
+    //                     .to_hash256()
+    //                     .map_err(ProtocolError::ValueError)
+    //                     .with_js_error()?;
+    //                 let id = <IdentifierWrapper as convert::From<Identifier>>::from(Identifier::from(
+    //                     buffer,
+    //                 ));
+    //                 return Ok(id.into());
+    //             }
+    //             BinaryType::None => {
+    //                 // Do nothing. If is 'None' it means that binary may contain binary data
+    //                 // or may not captain it at all
+    //             }
+    //         }
+    //
+    //         let json_value: JsonValue = value
+    //             .clone()
+    //             .try_into()
+    //             .map_err(ProtocolError::ValueError)
+    //             .with_js_error()?;
+    //         let map = value
+    //             .to_btree_ref_string_map()
+    //             .map_err(ProtocolError::ValueError)
+    //             .with_js_error()?;
+    //         let js_value = json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?;
+    //
+    //         let document_type = data_contract
+    //             .inner()
+    //             .document_type_for_name(self.inner.base().document_type_name())
+    //             .with_js_error()?;
+    //         let identifier_paths = document_type.identifier_paths();
+    //         let binary_paths = document_type.binary_paths();
+    //
+    //         for property_path in identifier_paths {
+    //             if property_path.starts_with(&path) {
+    //                 let (_, suffix) = property_path.split_at(path.len() + 1);
+    //
+    //                 if let Some(bytes) = map
+    //                     .get_optional_bytes_at_path(suffix)
+    //                     .map_err(ProtocolError::ValueError)
+    //                     .with_js_error()?
+    //                 {
+    //                     let id = <IdentifierWrapper as convert::From<Identifier>>::from(
+    //                         Identifier::from_bytes(&bytes).unwrap(),
+    //                     );
+    //                     lodash_set(&js_value, suffix, id.into());
+    //                 }
+    //             }
+    //         }
+    //
+    //         for property_path in binary_paths {
+    //             if property_path.starts_with(&path) {
+    //                 let (_, suffix) = property_path.split_at(path.len() + 1);
+    //
+    //                 if let Some(bytes) = map
+    //                     .get_optional_bytes_at_path(suffix)
+    //                     .map_err(ProtocolError::ValueError)
+    //                     .with_js_error()?
+    //                 {
+    //                     let buffer = Buffer::from_bytes(&bytes);
+    //                     lodash_set(&js_value, suffix, buffer.into());
+    //                 }
+    //             }
+    //         }
+    //         Ok(js_value)
+    //     }
+    //
+    //     // DocumentTransitionObjectLike
+    //     #[wasm_bindgen(js_name=toObject)]
+    //     pub fn to_object(&self, options: &JsValue) -> Result<JsValue, JsValue> {
+    //         let (identifiers_paths, binary_paths) = self
+    //             .inner
+    //             .base()
+    //             .data_contract
+    //             .get_identifiers_and_binary_paths(&self.inner.base().document_type_name)
+    //             .with_js_error()?;
+    //
+    //         to_object(
+    //             self.inner.to_object().with_js_error()?,
+    //             options,
+    //             identifiers_paths
+    //                 .into_iter()
+    //                 .chain(document_create_transition::v0::IDENTIFIER_FIELDS),
+    //             binary_paths
+    //                 .into_iter()
+    //                 .chain(document_create_transition::v0::BINARY_FIELDS),
+    //         )
+    //     }
+    //
+    //     #[wasm_bindgen(js_name=toJSON)]
+    //     pub fn to_json(&self) -> Result<JsValue, JsValue> {
+    //         let value = self.inner.to_json().with_js_error()?;
+    //         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+    //         let js_value = value.serialize(&serializer)?;
+    //         Ok(js_value)
+    //     }
+    //
+    //     // AbstractDataDocumentTransition
+    //     #[wasm_bindgen(js_name=getData)]
+    //     pub fn get_data(&self) -> Result<JsValue, JsValue> {
+    //         let json_data = if let Some(ref data) = self.inner.data() {
+    //             data.to_json_value()
+    //                 .map_err(ProtocolError::ValueError)
+    //                 .with_js_error()?
+    //         } else {
+    //             return Ok(JsValue::undefined());
+    //         };
+    //
+    //         let js_value = json_data.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?;
+    //         Ok(js_value)
+    //     }
+    // }
+    //
+    // impl DocumentCreateTransitionWasm {
+    //     fn get_binary_type_of_path(&self, path: &String) -> BinaryType {
+    //         let maybe_binary_properties = self
+    //             .inner
+    //             .base
+    //             .data_contract
+    //             .get_binary_properties(&self.inner.base.document_type_name);
+    //
+    //         if let Ok(binary_properties) = maybe_binary_properties {
+    //             if let Some(data) = binary_properties.get(path) {
+    //                 if data.is_type_of_identifier() {
+    //                     return BinaryType::Identifier;
+    //                 }
+    //                 return BinaryType::Buffer;
+    //             }
+    //         }
+    //         BinaryType::None
+    //     }
 }

package/src/document/state_transition/document_batch_transition/document_transition/mod.rs

@@ -1,4 +1,4 @@
-// mod document_create_transition;
+mod document_create_transition;
 // mod document_delete_transition;
 // mod document_replace_transition;
 

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

@@ -1,8 +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)]
@@ -19,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)]

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

@@ -24,27 +24,27 @@ impl From<&JsonSchemaError> for JsonSchemaErrorWasm {
 #[wasm_bindgen(js_class=JsonSchemaError)]
 impl JsonSchemaErrorWasm {
     #[wasm_bindgen(js_name=getKeyword)]
-    pub fn keyword(&self) -> String {
+    pub fn get_keyword(&self) -> String {
         self.inner.keyword().to_string()
     }
 
     #[wasm_bindgen(js_name=getInstancePath)]
-    pub fn instance_path(&self) -> String {
+    pub fn get_instance_path(&self) -> String {
         self.inner.instance_path().to_string()
     }
 
     #[wasm_bindgen(js_name=getSchemaPath)]
-    pub fn schema_path(&self) -> String {
+    pub fn get_schema_path(&self) -> String {
         self.inner.schema_path().to_string()
     }
 
     #[wasm_bindgen(js_name=getPropertyName)]
-    pub fn property_name(&self) -> String {
+    pub fn get_property_name(&self) -> String {
         self.inner.property_name().to_string()
     }
 
     #[wasm_bindgen(js_name=getParams)]
-    pub fn params(&self) -> Result<JsValue, JsError> {
+    pub fn get_params(&self) -> Result<JsValue, JsError> {
         let ser = serde_wasm_bindgen::Serializer::json_compatible();
 
         self.inner.params().serialize(&ser).map_err(|e| e.into())
@@ -64,4 +64,34 @@ impl JsonSchemaErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
+
+    #[wasm_bindgen(getter)]
+    pub fn keyword(&self) -> String {
+        self.get_keyword()
+    }
+
+    #[wasm_bindgen(getter, js_name=instancePath)]
+    pub fn instance_path(&self) -> String {
+        self.get_instance_path()
+    }
+
+    #[wasm_bindgen(getter, js_name=schemaPath)]
+    pub fn schema_path(&self) -> String {
+        self.get_schema_path()
+    }
+
+    #[wasm_bindgen(getter, js_name=propertyName)]
+    pub fn property_name(&self) -> String {
+        self.get_property_name()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn params(&self) -> Result<JsValue, JsError> {
+        self.get_params()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn code(&self) -> u32 {
+        self.get_code()
+    }
 }

package/src/identity/identity_facade.rs

@@ -128,12 +128,14 @@ impl IdentityFacadeWasm {
         instant_lock: Vec<u8>,
         asset_lock_transaction: Vec<u8>,
         output_index: u32,
-    ) -> Result<InstantAssetLockProofWasm, JsValue> {
-        let instant_lock: InstantLock =
-            consensus::deserialize(&instant_lock).map_err(|e| e.to_string())?;
+    ) -> Result<InstantAssetLockProofWasm, JsError> {
+        let instant_lock: InstantLock = consensus::deserialize(&instant_lock)
+            .map_err(|e| JsError::new(format!("can't deserialize instant lock: {e}").as_str()))?;
 
-        let asset_lock_transaction: Transaction =
-            consensus::deserialize(&asset_lock_transaction).map_err(|e| e.to_string())?;
+        let asset_lock_transaction: Transaction = consensus::deserialize(&asset_lock_transaction)
+            .map_err(|e| {
+            JsError::new(format!("can't deserialize transaction: {e}").as_str())
+        })?;
 
         Ok(IdentityFacade::create_instant_lock_proof(
             instant_lock,