pshenmic-dpp 1.0.5 → 1.0.6

package/packages/document/src/lib.rs

@@ -5,16 +5,17 @@ use dpp::identifier::Identifier;
 use dpp::identity::TimestampMillis;
 use dpp::platform_value::Value;
 use dpp::prelude::{BlockHeight, CoreBlockHeight, Revision};
+use pshenmic_dpp_identifier::IdentifierWASM;
 use std::collections::BTreeMap;
 use wasm_bindgen::prelude::wasm_bindgen;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Clone)]
 #[wasm_bindgen(js_name = DocumentWASM)]
 pub struct DocumentWASM {
-    id: Identifier,
-    owner_id: Identifier,
+    id: IdentifierWASM,
+    owner_id: IdentifierWASM,
     revision: Option<Revision>,
-    data_contract_id: Identifier,
+    data_contract_id: IdentifierWASM,
     document_type_name: String,
     properties: BTreeMap<String, Value>,
     created_at: Option<TimestampMillis>,
@@ -32,8 +33,8 @@ pub struct DocumentWASM {
 impl From<DocumentWASM> for Document {
     fn from(wasm_doc: DocumentWASM) -> Self {
         Document::V0(DocumentV0 {
-            id: wasm_doc.id,
-            owner_id: wasm_doc.owner_id,
+            id: wasm_doc.id.into(),
+            owner_id: wasm_doc.owner_id.into(),
             properties: wasm_doc.properties,
             revision: wasm_doc.revision,
             created_at: wasm_doc.created_at,
@@ -52,10 +53,10 @@ impl From<DocumentWASM> for Document {
 impl From<Document> for DocumentWASM {
     fn from(doc: Document) -> Self {
         DocumentWASM {
-            id: doc.id(),
-            owner_id: doc.owner_id(),
+            id: doc.id().into(),
+            owner_id: doc.owner_id().into(),
             revision: doc.revision(),
-            data_contract_id: Default::default(),
+            data_contract_id: Identifier::default().into(),
             document_type_name: "".to_string(),
             properties: doc.properties().clone(),
             created_at: doc.created_at(),
@@ -80,10 +81,10 @@ impl DocumentWASM {
         entropy: Option<[u8; 32]>,
     ) -> Self {
         DocumentWASM {
-            id: document.id(),
-            owner_id: document.owner_id(),
+            id: document.id().into(),
+            owner_id: document.owner_id().into(),
             revision: document.revision(),
-            data_contract_id,
+            data_contract_id: data_contract_id.into(),
             document_type_name,
             properties: document.properties().clone(),
             created_at: document.created_at(),

package/packages/document/src/methods/mod.rs

@@ -12,7 +12,8 @@ use dpp::util::entropy_generator;
 use dpp::util::entropy_generator::EntropyGenerator;
 use pshenmic_dpp_data_contract::DataContractWASM;
 use pshenmic_dpp_enums::platform::PlatformVersionWASM;
-use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError, identifier_from_js_value};
+use pshenmic_dpp_identifier::IdentifierWASM;
+use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError};
 use std::collections::BTreeMap;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
@@ -24,36 +25,35 @@ impl DocumentWASM {
         js_raw_document: JsValue,
         js_document_type_name: &str,
         js_revision: u64,
-        js_data_contract_id: JsValue,
-        js_owner_id: JsValue,
+        js_data_contract_id: &JsValue,
+        js_owner_id: &JsValue,
         js_document_id: JsValue,
     ) -> Result<DocumentWASM, JsValue> {
+        let data_contract_id = IdentifierWASM::try_from(js_data_contract_id)?;
+        let owner_id = IdentifierWASM::try_from(js_owner_id)?;
+
         let revision = Revision::from(js_revision);
 
         let document = js_raw_document
             .with_serde_to_platform_value_map()
             .expect("cannot convert document to platform value map");
 
-        let owner_id = identifier_from_js_value(&js_owner_id)?;
-        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
         let revision = Revision::from(revision);
 
         let entropy = entropy_generator::DefaultEntropyGenerator
             .generate()
             .unwrap();
 
-        let document_id: Identifier = {
-            if JsValue::UNDEFINED == js_document_id {
-                pshenmic_dpp_utils::generate_document_id_v0(
-                    &data_contract_id,
-                    &owner_id,
-                    js_document_type_name,
-                    &entropy,
-                )
-            } else {
-                identifier_from_js_value(&js_document_id)
-            }
-        }?;
+        let document_id: IdentifierWASM = match js_document_id.is_undefined() {
+            true => pshenmic_dpp_utils::generate_document_id_v0(
+                &data_contract_id.into(),
+                &owner_id.into(),
+                js_document_type_name,
+                &entropy,
+            )?
+            .into(),
+            false => js_document_id.try_into()?,
+        };
 
         Ok(DocumentWASM {
             owner_id,
@@ -76,8 +76,8 @@ impl DocumentWASM {
     }
 
     #[wasm_bindgen(js_name=getId)]
-    pub fn get_id(&self) -> Vec<u8> {
-        self.id.to_vec()
+    pub fn get_id(&self) -> IdentifierWASM {
+        self.id
     }
 
     #[wasm_bindgen(js_name=getEntropy)]
@@ -89,13 +89,13 @@ impl DocumentWASM {
     }
 
     #[wasm_bindgen(js_name=getDataContractId)]
-    pub fn get_data_contract_id(&self) -> Vec<u8> {
-        self.data_contract_id.to_vec()
+    pub fn get_data_contract_id(&self) -> IdentifierWASM {
+        self.data_contract_id
     }
 
     #[wasm_bindgen(js_name=getOwnerId)]
-    pub fn get_owner_id(&self) -> Vec<u8> {
-        self.owner_id.to_vec()
+    pub fn get_owner_id(&self) -> IdentifierWASM {
+        self.owner_id
     }
 
     #[wasm_bindgen(js_name=getProperties)]
@@ -167,8 +167,9 @@ impl DocumentWASM {
     }
 
     #[wasm_bindgen(js_name=setId)]
-    pub fn set_id(&mut self, id: JsValue) {
-        self.id = identifier_from_js_value(&id).unwrap()
+    pub fn set_id(&mut self, id: &JsValue) -> Result<(), JsValue> {
+        self.id = IdentifierWASM::try_from(id)?.clone();
+        Ok(())
     }
 
     #[wasm_bindgen(js_name=setEntropy)]
@@ -188,8 +189,9 @@ impl DocumentWASM {
     }
 
     #[wasm_bindgen(js_name=setOwnerId)]
-    pub fn set_owner_id(&mut self, id: JsValue) {
-        self.owner_id = identifier_from_js_value(&id).unwrap()
+    pub fn set_owner_id(&mut self, id: &JsValue) -> Result<(), JsValue> {
+        self.owner_id = IdentifierWASM::try_from(id)?.clone();
+        Ok(())
     }
 
     #[wasm_bindgen(js_name=setProperties)]
@@ -263,7 +265,7 @@ impl DocumentWASM {
         js_platform_version: JsValue,
     ) -> Result<Vec<u8>, JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -289,7 +291,7 @@ impl DocumentWASM {
         js_platform_version: JsValue,
     ) -> Result<DocumentWASM, JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -314,12 +316,13 @@ impl DocumentWASM {
     #[wasm_bindgen(js_name=generateId)]
     pub fn generate_id(
         js_document_type_name: &str,
-        js_owner_id: JsValue,
-        js_data_contract_id: JsValue,
+        js_owner_id: &JsValue,
+        js_data_contract_id: &JsValue,
         opt_entropy: Option<Vec<u8>>,
     ) -> Result<Vec<u8>, JsValue> {
-        let owner_id = identifier_from_js_value(&js_owner_id)?;
-        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
+        let owner_id = IdentifierWASM::try_from(js_owner_id)?;
+        let data_contract_id = IdentifierWASM::try_from(js_data_contract_id)?;
+
         let entropy: [u8; 32] = match opt_entropy {
             Some(entropy_vec) => {
                 let mut entropy = [0u8; 32];
@@ -334,8 +337,8 @@ impl DocumentWASM {
         };
 
         let identifier = pshenmic_dpp_utils::generate_document_id_v0(
-            &data_contract_id,
-            &owner_id,
+            &data_contract_id.into(),
+            &owner_id.into(),
             js_document_type_name,
             &entropy,
         );
@@ -349,15 +352,15 @@ impl DocumentWASM {
 
 impl DocumentWASM {
     pub fn rs_get_owner_id(&self) -> Identifier {
-        self.owner_id
+        self.owner_id.into()
     }
 
     pub fn rs_get_id(&self) -> Identifier {
-        self.id
+        self.id.into()
     }
 
     pub fn rs_get_data_contract_id(&self) -> Identifier {
-        self.data_contract_id
+        self.data_contract_id.into()
     }
 
     pub fn rs_get_entropy(&self) -> Option<[u8; 32]> {

package/packages/documents_batch/Cargo.toml

@@ -10,10 +10,11 @@ crate-type = ["cdylib", "lib"]
 wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
 pshenmic_dpp_document = {path = "../document"}
 pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_identifier = {path = "../identifier"}
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_state_transition = {path = "../state_transition"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "document-json-conversion",
 ]}
-js-sys = "0.3.77"
+js-sys = "0.3.53"
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }

package/packages/documents_batch/src/document_base_transition/mod.rs

@@ -2,7 +2,7 @@ use dpp::prelude::IdentityNonce;
 use dpp::state_transition::documents_batch_transition::document_base_transition::DocumentBaseTransition;
 use dpp::state_transition::documents_batch_transition::document_base_transition::v0::DocumentBaseTransitionV0;
 use dpp::state_transition::documents_batch_transition::document_base_transition::v0::v0_methods::DocumentBaseTransitionV0Methods;
-use pshenmic_dpp_utils::identifier_from_js_value;
+use pshenmic_dpp_identifier::IdentifierWASM;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -26,19 +26,16 @@ impl From<DocumentBaseTransitionWASM> for DocumentBaseTransition {
 impl DocumentBaseTransitionWASM {
     #[wasm_bindgen(constructor)]
     pub fn new(
-        js_document_id: JsValue,
+        js_document_id: &JsValue,
         identity_contract_nonce: IdentityNonce,
         document_type_name: String,
-        js_data_contract_id: JsValue,
+        js_data_contract_id: &JsValue,
     ) -> Result<DocumentBaseTransitionWASM, JsValue> {
-        let document_id = identifier_from_js_value(&js_document_id)?;
-        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
-
         let rs_base_v0 = DocumentBaseTransitionV0 {
-            id: document_id,
+            id: IdentifierWASM::try_from(js_document_id)?.into(),
             identity_contract_nonce,
             document_type_name,
-            data_contract_id,
+            data_contract_id: IdentifierWASM::try_from(js_data_contract_id)?.into(),
         };
 
         Ok(DocumentBaseTransitionWASM(DocumentBaseTransition::from(
@@ -47,8 +44,8 @@ impl DocumentBaseTransitionWASM {
     }
 
     #[wasm_bindgen(getter = "id")]
-    pub fn get_id(&self) -> Vec<u8> {
-        self.0.id().to_vec()
+    pub fn get_id(&self) -> IdentifierWASM {
+        self.0.id().into()
     }
 
     #[wasm_bindgen(getter = "identityContractNonce")]
@@ -57,8 +54,8 @@ impl DocumentBaseTransitionWASM {
     }
 
     #[wasm_bindgen(getter = "dataContractId")]
-    pub fn get_data_contract_id(&self) -> Vec<u8> {
-        self.0.data_contract_id().to_vec()
+    pub fn get_data_contract_id(&self) -> IdentifierWASM {
+        self.0.data_contract_id().into()
     }
 
     #[wasm_bindgen(getter = "documentTypeName")]
@@ -67,10 +64,9 @@ impl DocumentBaseTransitionWASM {
     }
 
     #[wasm_bindgen(setter = "id")]
-    pub fn set_id(&mut self, js_id: JsValue) -> Result<(), JsValue> {
-        let id = identifier_from_js_value(&js_id)?;
-
-        Ok(self.0.set_id(id))
+    pub fn set_id(&mut self, js_id: &JsValue) -> Result<(), JsValue> {
+        self.0.set_id(IdentifierWASM::try_from(js_id)?.into());
+        Ok(())
     }
 
     #[wasm_bindgen(setter = "identityContractNonce")]
@@ -79,10 +75,10 @@ impl DocumentBaseTransitionWASM {
     }
 
     #[wasm_bindgen(setter = "dataContractId")]
-    pub fn set_data_contract_id(&mut self, js_data_contract_id: JsValue) -> Result<(), JsValue> {
-        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
-
-        Ok(self.0.set_data_contract_id(data_contract_id))
+    pub fn set_data_contract_id(&mut self, js_data_contract_id: &JsValue) -> Result<(), JsValue> {
+        self.0
+            .set_data_contract_id(IdentifierWASM::try_from(js_data_contract_id)?.into());
+        Ok(())
     }
 
     #[wasm_bindgen(setter = "documentTypeName")]

package/packages/documents_batch/src/document_transition/mod.rs

@@ -10,7 +10,7 @@ use dpp::state_transition::documents_batch_transition::document_transition::{
     DocumentTransition, DocumentTransitionV0Methods,
 };
 use pshenmic_dpp_enums::batch::batch_enum::BatchTypeWASM;
-use pshenmic_dpp_utils::identifier_from_js_value;
+use pshenmic_dpp_identifier::IdentifierWASM;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -38,13 +38,13 @@ impl DocumentTransitionWASM {
     }
 
     #[wasm_bindgen(getter = "dataContractId")]
-    pub fn get_data_contract_id(&self) -> Vec<u8> {
-        self.0.data_contract_id().to_vec()
+    pub fn get_data_contract_id(&self) -> IdentifierWASM {
+        self.0.data_contract_id().into()
     }
 
     #[wasm_bindgen(getter = "id")]
-    pub fn get_id(&self) -> Vec<u8> {
-        self.0.get_id().to_vec()
+    pub fn get_id(&self) -> IdentifierWASM {
+        self.0.get_id().into()
     }
 
     #[wasm_bindgen(getter = "documentTypeName")]
@@ -126,10 +126,10 @@ impl DocumentTransitionWASM {
     }
 
     #[wasm_bindgen(setter = "dataContractId")]
-    pub fn set_data_contract_id(&mut self, js_data_contract_id: JsValue) -> Result<(), JsValue> {
-        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
-
-        Ok(self.0.set_data_contract_id(data_contract_id))
+    pub fn set_data_contract_id(&mut self, js_data_contract_id: &JsValue) -> Result<(), JsValue> {
+        Ok(self
+            .0
+            .set_data_contract_id(IdentifierWASM::try_from(js_data_contract_id)?.into()))
     }
 
     #[wasm_bindgen(setter = "revision")]

package/packages/documents_batch/src/lib.rs

@@ -11,8 +11,9 @@ use dpp::state_transition::documents_batch_transition::{
     DocumentsBatchTransition, DocumentsBatchTransitionV0,
 };
 use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned, StateTransitionLike};
+use pshenmic_dpp_identifier::IdentifierWASM;
 use pshenmic_dpp_state_transition::StateTransitionWASM;
-use pshenmic_dpp_utils::{IntoWasm, WithJsError, identifier_from_js_value};
+use pshenmic_dpp_utils::{IntoWasm, WithJsError};
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -42,15 +43,16 @@ impl From<DocumentsBatchWASM> for DocumentsBatchTransition {
 impl DocumentsBatchWASM {
     #[wasm_bindgen(constructor)]
     pub fn new(
-        document_transitions: js_sys::Array,
-        js_owner_id: JsValue,
+        document_transitions: &js_sys::Array,
+        js_owner_id: &JsValue,
         user_fee_increase: Option<UserFeeIncrease>,
         signature_public_key_id: Option<KeyID>,
         signature: Option<Vec<u8>>,
     ) -> Result<DocumentsBatchWASM, JsValue> {
-        let owner_id = identifier_from_js_value(&js_owner_id)?;
+        let owner_id = IdentifierWASM::try_from(js_owner_id)?;
 
         let transitions: Vec<DocumentTransition> = document_transitions
+            .clone()
             .iter()
             .map(|js_document_transition| {
                 let document_transition: DocumentTransitionWASM = js_document_transition
@@ -64,7 +66,7 @@ impl DocumentsBatchWASM {
 
         Ok(DocumentsBatchWASM(DocumentsBatchTransition::V0(
             DocumentsBatchTransitionV0 {
-                owner_id,
+                owner_id: owner_id.into(),
                 transitions,
                 user_fee_increase: user_fee_increase.unwrap_or(0),
                 signature_public_key_id: signature_public_key_id.unwrap_or(0),
@@ -99,20 +101,17 @@ impl DocumentsBatchWASM {
     }
 
     #[wasm_bindgen(getter = "ownerId")]
-    pub fn get_owner_id(&self) -> Vec<u8> {
-        self.0.owner_id().to_vec()
+    pub fn get_owner_id(&self) -> IdentifierWASM {
+        self.0.owner_id().into()
     }
 
     #[wasm_bindgen(getter = "modifiedDataIds")]
-    pub fn get_modified_data_ids(&self) -> Result<JsValue, JsValue> {
-        let vec_of_ids: Vec<Vec<u8>> = self
-            .0
+    pub fn get_modified_data_ids(&self) -> Vec<IdentifierWASM> {
+        self.0
             .modified_data_ids()
             .iter()
-            .map(|id| id.to_vec())
-            .collect();
-
-        serde_wasm_bindgen::to_value(&vec_of_ids).map_err(JsValue::from)
+            .map(|id| id.clone().into())
+            .collect()
     }
 
     #[wasm_bindgen(getter = "allConflictingIndexCollateralVotingFunds")]
@@ -125,10 +124,18 @@ impl DocumentsBatchWASM {
     }
 
     #[wasm_bindgen(setter = "transitions")]
-    pub fn set_transitions(&mut self, transitions: Vec<DocumentTransitionWASM>) {
+    pub fn set_transitions(&mut self, transitions: &js_sys::Array) {
         let rs_transitions = transitions
+            .clone()
             .iter()
-            .map(|transition| DocumentTransition::from(transition.clone().clone()))
+            .map(|js_document_transition| {
+                let document_transition: DocumentTransitionWASM = js_document_transition
+                    .to_wasm::<DocumentTransitionWASM>("DocumentTransitionWASM")
+                    .unwrap()
+                    .clone();
+
+                DocumentTransition::from(document_transition.clone().clone())
+            })
             .collect();
 
         self.0.set_transitions(rs_transitions);

package/packages/documents_batch/src/transitions/create/mod.rs

@@ -9,8 +9,8 @@ use dpp::state_transition::documents_batch_transition::document_create_transitio
 use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransition;
 use pshenmic_dpp_document::DocumentWASM;
 use pshenmic_dpp_utils::ToSerdeJSONExt;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
-use wasm_bindgen::{JsError, JsValue};
 
 #[wasm_bindgen(js_name = "DocumentCreateTransitionWASM")]
 #[derive(Clone)]
@@ -76,7 +76,10 @@ impl DocumentCreateTransitionWASM {
 
     #[wasm_bindgen(setter = "entropy")]
     pub fn set_entropy(&mut self, js_entropy: Vec<u8>) -> Result<(), JsValue> {
-        let entropy: [u8; 32] = js_entropy.as_slice().try_into().map_err(JsError::from)?;
+        let mut entropy = [0u8; 32];
+        let bytes = js_entropy.as_slice();
+        let len = bytes.len().min(32);
+        entropy[..len].copy_from_slice(&bytes[..len]);
 
         Ok(self.0.set_entropy(entropy))
     }

package/packages/documents_batch/src/transitions/transfer/mod.rs

@@ -4,7 +4,7 @@ use dpp::state_transition::documents_batch_transition::document_transition::{Doc
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 use pshenmic_dpp_document::DocumentWASM;
-use pshenmic_dpp_utils::identifier_from_js_value;
+use pshenmic_dpp_identifier::IdentifierWASM;
 use crate::document_base_transition::DocumentBaseTransitionWASM;
 use crate::document_transition::DocumentTransitionWASM;
 use crate::generators::generate_transfer_transition;
@@ -31,15 +31,13 @@ impl DocumentTransferTransitionWASM {
         document: &DocumentWASM,
         identity_contract_nonce: IdentityNonce,
         document_type_name: String,
-        js_recipient_owner_id: JsValue,
+        js_recipient_owner_id: &JsValue,
     ) -> Result<DocumentTransferTransitionWASM, JsValue> {
-        let recipient_owner_id = identifier_from_js_value(&js_recipient_owner_id)?;
-
         let rs_transfer_transition = generate_transfer_transition(
             document.clone(),
             identity_contract_nonce,
             document_type_name,
-            recipient_owner_id,
+            IdentifierWASM::try_from(js_recipient_owner_id)?.into(),
         );
 
         Ok(DocumentTransferTransitionWASM(rs_transfer_transition))
@@ -51,8 +49,8 @@ impl DocumentTransferTransitionWASM {
     }
 
     #[wasm_bindgen(getter = "recipientId")]
-    pub fn get_recipient_owner_id(&self) -> Vec<u8> {
-        self.0.recipient_owner_id().to_vec()
+    pub fn get_recipient_owner_id(&self) -> IdentifierWASM {
+        self.0.recipient_owner_id().into()
     }
 
     #[wasm_bindgen(setter = "base")]
@@ -63,11 +61,11 @@ impl DocumentTransferTransitionWASM {
     #[wasm_bindgen(setter = "recipientId")]
     pub fn set_recipient_owner_id(
         &mut self,
-        js_recipient_owner_id: JsValue,
+        js_recipient_owner_id: &JsValue,
     ) -> Result<(), JsValue> {
-        let recipient_owner_id = identifier_from_js_value(&js_recipient_owner_id)?;
-
-        Ok(self.0.set_recipient_owner_id(recipient_owner_id))
+        self.0
+            .set_recipient_owner_id(IdentifierWASM::try_from(js_recipient_owner_id)?.into());
+        Ok(())
     }
 
     #[wasm_bindgen(js_name = "toDocumentTransition")]

package/packages/enums/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2024"
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = "0.2.100"
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "state-transitions"
 ]}

package/packages/enums/src/batch/batch_enum.rs

@@ -25,8 +25,8 @@ impl TryFrom<JsValue> for BatchTypeWASM {
                     "delete" => Ok(BatchTypeWASM::Delete),
                     "transfer" => Ok(BatchTypeWASM::Transfer),
                     "purchase" => Ok(BatchTypeWASM::Purchase),
-                    "updatePrice" => Ok(BatchTypeWASM::UpdatePrice),
-                    "ignoreWhileBumpingRevision" => Ok(BatchTypeWASM::IgnoreWhileBumpingRevision),
+                    "updateprice" => Ok(BatchTypeWASM::UpdatePrice),
+                    "ignorewhilebumpingrevision" => Ok(BatchTypeWASM::IgnoreWhileBumpingRevision),
                     _ => Err(JsValue::from(format!(
                         "unknown batch type value: {}",
                         enum_val

package/packages/enums/src/lib.rs

@@ -1,4 +1,6 @@
 pub mod batch;
 pub mod keys;
+pub mod lock_types;
 pub mod network;
 pub mod platform;
+pub mod withdrawal;

package/packages/enums/src/lock_types/mod.rs

@@ -0,0 +1,65 @@
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::{JsError, JsValue};
+
+#[wasm_bindgen(js_name = "AssetLockProofTypeWASM")]
+pub enum AssetLockProofTypeWASM {
+    Instant = 0,
+    Chain = 1,
+}
+
+impl From<AssetLockProofTypeWASM> for String {
+    fn from(value: AssetLockProofTypeWASM) -> Self {
+        match value {
+            AssetLockProofTypeWASM::Instant => String::from("Instant"),
+            AssetLockProofTypeWASM::Chain => String::from("Chain"),
+        }
+    }
+}
+
+impl TryFrom<JsValue> for AssetLockProofTypeWASM {
+    type Error = JsValue;
+
+    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        match value.is_string() {
+            true => match value.as_string() {
+                None => Err(JsValue::from("cannot read value from enum")),
+                Some(enum_val) => match enum_val.to_lowercase().as_str() {
+                    "instant" => Ok(AssetLockProofTypeWASM::Instant),
+                    "chain" => Ok(AssetLockProofTypeWASM::Chain),
+                    _ => Err(JsValue::from(format!("unsupported lock type {}", enum_val))),
+                },
+            },
+            false => match value.as_f64() {
+                None => Err(JsValue::from("cannot read value from enum")),
+                Some(enum_val) => match enum_val as u8 {
+                    0 => Ok(AssetLockProofTypeWASM::Instant),
+                    1 => Ok(AssetLockProofTypeWASM::Chain),
+                    _ => Err(JsValue::from(format!("unsupported lock type {}", enum_val))),
+                },
+            },
+        }
+    }
+}
+
+impl TryFrom<u8> for AssetLockProofTypeWASM {
+    type Error = JsError;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Instant),
+            1 => Ok(Self::Chain),
+            _ => Err(JsError::new("Unexpected asset lock proof type")),
+        }
+    }
+}
+
+impl TryFrom<u64> for AssetLockProofTypeWASM {
+    type Error = JsError;
+
+    fn try_from(value: u64) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(Self::Instant),
+            1 => Ok(Self::Chain),
+            _ => Err(JsError::new("Unexpected asset lock proof type")),
+        }
+    }
+}

package/packages/enums/src/platform/mod.rs

@@ -11,8 +11,10 @@ use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name = "PlatformVersionWASM")]
+#[derive(Default)]
 #[allow(non_camel_case_types)]
 pub enum PlatformVersionWASM {
+    #[default]
     PLATFORM_V1 = 0,
     PLATFORM_V2 = 1,
     PLATFORM_V3 = 2,