pshenmic-dpp 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pshenmic-dpp",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "main": "dist/wasm/pshenmic_dpp.js",
   "repository": {
     "type": "git",
@@ -20,5 +20,6 @@
     "babel": "^6.23.0",
     "babel-cli": "^6.26.0",
     "typescript": "^5.8.2"
-  }
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

package/packages/data_contract/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "pshenmic_dpp_data_contract"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_enums = {path = "../enums"}
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "data-contract-json-conversion"
+]}
+serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
+#serde = { version = "1.0.219", features = ["derive"] }
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/data_contract/src/lib.rs

@@ -0,0 +1,147 @@
+use dpp::dashcore::hashes::serde::Serialize;
+use dpp::data_contract::accessors::v0::DataContractV0Getters;
+use dpp::data_contract::conversion::json::DataContractJsonConversionMethodsV0;
+use dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0;
+use dpp::data_contract::document_type::DocumentTypeRef;
+use dpp::data_contract::errors::DataContractError;
+use dpp::data_contract::schema::DataContractSchemaMethodsV0;
+use dpp::data_contract::{DataContract, DataContractV0};
+use dpp::platform_value::string_encoding::Encoding::Base58;
+use dpp::serialization::{
+    PlatformDeserializableWithPotentialValidationFromVersionedStructure,
+    PlatformSerializableWithPlatformVersion,
+};
+use pshenmic_dpp_enums::platform::PlatformVersionWASM;
+use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError};
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "DataContractWASM")]
+#[derive(Clone)]
+pub struct DataContractWASM(DataContract);
+
+impl From<DataContract> for DataContractWASM {
+    fn from(v: DataContract) -> Self {
+        DataContractWASM(v)
+    }
+}
+
+impl From<DataContractWASM> for DataContract {
+    fn from(v: DataContractWASM) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen]
+impl DataContractWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        js_value: JsValue,
+        full_validation: bool,
+        platform_version: PlatformVersionWASM,
+    ) -> Result<DataContractWASM, JsValue> {
+        let value = js_value.with_serde_to_platform_value();
+
+        match value {
+            Ok(v) => {
+                let v0_contract =
+                    DataContractV0::from_value(v, full_validation, &platform_version.into())
+                        .with_js_error()?;
+
+                Ok(DataContractWASM(DataContract::V0(v0_contract)))
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(
+        bytes: Vec<u8>,
+        full_validation: bool,
+        platform_version: PlatformVersionWASM,
+    ) -> Result<DataContractWASM, JsValue> {
+        let rs_data_contract = DataContract::versioned_deserialize(
+            &bytes.as_slice(),
+            full_validation,
+            &platform_version.into(),
+        )
+        .with_js_error();
+
+        match rs_data_contract {
+            Ok(rs_data_contract) => Ok(DataContractWASM(rs_data_contract)),
+            Err(err) => Err(err),
+        }
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self, platform_version: PlatformVersionWASM) -> Result<Vec<u8>, JsValue> {
+        let rs_data_contract: DataContract = self.0.clone();
+
+        rs_data_contract
+            .serialize_to_bytes_with_platform_version(&platform_version.into())
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "toValue")]
+    pub fn to_value(&self, platform_version: PlatformVersionWASM) -> Result<JsValue, JsValue> {
+        let value = self
+            .0
+            .clone()
+            .to_value(&platform_version.into())
+            .with_js_error();
+
+        match value {
+            Ok(v) => Ok(serde_wasm_bindgen::to_value(&v).unwrap()),
+            Err(err) => Err(err),
+        }
+    }
+
+    #[wasm_bindgen(js_name = "getSchema")]
+    pub fn get_schema(&self) -> JsValue {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        self.0.document_schemas().serialize(&serializer).unwrap()
+    }
+
+    #[wasm_bindgen(js_name = "getDataContractVersion")]
+    pub fn get_data_contract_version(&self) -> u32 {
+        self.0.version()
+    }
+
+    #[wasm_bindgen(js_name = "getDataContractIdentifier")]
+    pub fn get_data_contract_identifier(&self) -> JsValue {
+        JsValue::from_str(&*self.0.id().to_string(Base58))
+    }
+
+    #[wasm_bindgen(js_name = "getOwnerId")]
+    pub fn get_owner_id(&self) -> JsValue {
+        JsValue::from_str(&*self.0.owner_id().to_string(Base58))
+    }
+
+    #[wasm_bindgen(js_name = "getConfig")]
+    pub fn get_config(&self) -> JsValue {
+        self.0
+            .config()
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .unwrap()
+    }
+
+    #[wasm_bindgen(js_name = "toJson")]
+    pub fn to_json(&self, platform_version: PlatformVersionWASM) -> Result<JsValue, JsValue> {
+        let json = self.0.to_json(&platform_version.into()).with_js_error();
+
+        match json {
+            Ok(json) => Ok(json.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?),
+            Err(err) => Err(err),
+        }
+    }
+}
+
+impl DataContractWASM {
+    pub fn get_document_type_ref_by_name(
+        &self,
+        name: String,
+    ) -> Result<DocumentTypeRef, DataContractError> {
+        self.0.document_type_for_name(name.as_str()).clone()
+    }
+}

package/packages/document/Cargo.toml

@@ -9,9 +9,12 @@ crate-type = ["cdylib", "lib"]
 [dependencies]
 wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_data_contract = {path = "../data_contract"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
-    "document-json-conversion"
+    "document-value-conversion"
 ]}
+#serde = { version = "1.0.197", features = ["derive"] }
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
 
 [profile.release]

package/packages/document/src/lib.rs

@@ -1,6 +1,6 @@
 mod methods;
 
-use dpp::document::{Document, DocumentV0Getters};
+use dpp::document::{Document, DocumentV0, DocumentV0Getters};
 use dpp::identifier::Identifier;
 use dpp::identity::TimestampMillis;
 use dpp::platform_value::Value;
@@ -29,6 +29,49 @@ pub struct DocumentWASM {
     entropy: Option<[u8; 32]>,
 }
 
+impl From<DocumentWASM> for Document {
+    fn from(wasm_doc: DocumentWASM) -> Self {
+        Document::V0(DocumentV0 {
+            id: wasm_doc.id,
+            owner_id: wasm_doc.owner_id,
+            properties: wasm_doc.properties,
+            revision: wasm_doc.revision,
+            created_at: wasm_doc.created_at,
+            updated_at: wasm_doc.updated_at,
+            transferred_at: wasm_doc.transferred_at,
+            created_at_block_height: wasm_doc.created_at_block_height,
+            updated_at_block_height: wasm_doc.updated_at_block_height,
+            transferred_at_block_height: wasm_doc.transferred_at_block_height,
+            created_at_core_block_height: wasm_doc.created_at_core_block_height,
+            updated_at_core_block_height: wasm_doc.updated_at_core_block_height,
+            transferred_at_core_block_height: wasm_doc.transferred_at_core_block_height,
+        })
+    }
+}
+
+impl From<Document> for DocumentWASM {
+    fn from(doc: Document) -> Self {
+        DocumentWASM {
+            id: doc.id(),
+            owner_id: doc.owner_id(),
+            revision: doc.revision(),
+            data_contract_id: Default::default(),
+            document_type_name: "".to_string(),
+            properties: doc.properties().clone(),
+            created_at: doc.created_at(),
+            updated_at: doc.updated_at(),
+            transferred_at: doc.transferred_at(),
+            created_at_block_height: doc.created_at_block_height(),
+            updated_at_block_height: doc.updated_at_block_height(),
+            transferred_at_block_height: doc.transferred_at_block_height(),
+            created_at_core_block_height: doc.created_at_core_block_height(),
+            updated_at_core_block_height: doc.updated_at_core_block_height(),
+            transferred_at_core_block_height: doc.transferred_at_core_block_height(),
+            entropy: None,
+        }
+    }
+}
+
 impl DocumentWASM {
     pub fn from_batch(
         document: Document,

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

@@ -1,14 +1,21 @@
 use crate::DocumentWASM;
+use dpp::ProtocolError;
+use dpp::dashcore::hashes::serde::Serialize;
+use dpp::data_contract::JsonValue;
+use dpp::document::Document;
+use dpp::document::serialization_traits::DocumentPlatformConversionMethodsV0;
 use dpp::platform_value::converter::serde_json::BTreeValueJsonConverter;
 use dpp::platform_value::string_encoding::Encoding::Base58;
 use dpp::prelude::Revision;
-use pshenmic_dpp_utils::{ToSerdeJSONExt, identifier_from_js_value};
+use pshenmic_dpp_data_contract::DataContractWASM;
+use pshenmic_dpp_enums::platform::PlatformVersionWASM;
+use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError, identifier_from_js_value};
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen]
 impl DocumentWASM {
-    #[wasm_bindgen(js_name=new)]
+    #[wasm_bindgen(constructor)]
     pub fn js_new(
         js_raw_document: JsValue,
         js_document_type_name: &str,
@@ -50,12 +57,15 @@ impl DocumentWASM {
     }
 
     #[wasm_bindgen(js_name=getProperties)]
-    pub fn js_get_properties(&self) -> JsValue {
-        let json = &self.properties.to_json_value().unwrap();
-
-        let obj = json.as_object().unwrap();
-
-        serde_wasm_bindgen::to_value(obj).unwrap()
+    pub fn js_get_properties(&self) -> Result<JsValue, JsValue> {
+        let json_value: JsonValue = self
+            .properties
+            .to_json_value()
+            .map_err(ProtocolError::ValueError)
+            .with_js_error()?;
+
+        let js_value = json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?;
+        Ok(js_value)
     }
 
     #[wasm_bindgen(js_name=getRevision)]
@@ -201,4 +211,50 @@ impl DocumentWASM {
     pub fn set_document_type_name(&mut self, document_type_name: &str) {
         self.document_type_name = document_type_name.to_string();
     }
+
+    #[wasm_bindgen(js_name=toBytes)]
+    pub fn to_bytes(
+        &self,
+        data_contract: &DataContractWASM,
+        type_name: String,
+        platform_version: PlatformVersionWASM,
+    ) -> Result<Vec<u8>, JsValue> {
+        let rs_document: Document = Document::from(self.clone());
+
+        let document_type_ref = data_contract
+            .get_document_type_ref_by_name(type_name)
+            .map_err(|err| JsValue::from_str(err.to_string().as_str()))?;
+
+        DocumentPlatformConversionMethodsV0::serialize(
+            &rs_document,
+            document_type_ref,
+            &platform_version.into(),
+        )
+        .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=fromBytes)]
+    pub fn from_bytes(
+        bytes: Vec<u8>,
+        data_contract: &DataContractWASM,
+        type_name: String,
+        platform_version: PlatformVersionWASM,
+    ) -> Result<DocumentWASM, JsValue> {
+        let document_type_ref = match data_contract.get_document_type_ref_by_name(type_name) {
+            Ok(type_ref) => Ok(type_ref),
+            Err(err) => Err(JsValue::from_str(err.to_string().as_str())),
+        }?;
+
+        let rs_document = Document::from_bytes(
+            bytes.as_slice(),
+            document_type_ref,
+            &platform_version.into(),
+        )
+        .with_js_error();
+
+        match rs_document {
+            Ok(doc) => Ok(DocumentWASM::from(doc)),
+            Err(err) => Err(err),
+        }
+    }
 }

package/packages/document_batch/Cargo.toml

@@ -12,10 +12,8 @@ pshenmic_dpp_document = {path = "../document"}
 pshenmic_dpp_enums = {path = "../enums"}
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_state_transition = {path = "../state_transition"}
-pshenmic_dpp_mock_bls = {path = "../mock_bls"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "document-json-conversion",
-    "state-transition-signing"
 ]}
 
 

package/packages/document_batch/src/lib.rs

@@ -83,7 +83,7 @@ impl From<(DocumentTransition, DocumentsBatchTransition)> for DocumentBatchWASM
 
 #[wasm_bindgen]
 impl DocumentBatchWASM {
-    #[wasm_bindgen(js_name=new)]
+    #[wasm_bindgen(constructor)]
     pub fn new(
         batch_type: BatchType,
         document: DocumentWASM,
@@ -163,8 +163,8 @@ impl DocumentBatchWASM {
         StateTransitionWASM::from(st)
     }
 
-    #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self) -> Result<JsValue, JsValue> {
+    #[wasm_bindgen(js_name=toBytes)]
+    pub fn to_bytes(&self) -> Result<JsValue, JsValue> {
         let bytes = self.batch.serialize_to_bytes().with_js_error();
 
         match bytes {
@@ -195,7 +195,8 @@ impl DocumentBatchWASM {
         }
     }
 
-    pub fn from_buffer(bytes: Vec<u8>) -> Result<DocumentBatchWASM, JsValue> {
+    #[wasm_bindgen(js_name=fromBytes)]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<DocumentBatchWASM, JsValue> {
         let batch_transition =
             DocumentsBatchTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error();
 

package/packages/enums/Cargo.toml

@@ -11,7 +11,6 @@ wasm-bindgen = "0.2.100"
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "identity-value-conversion",
 ]}
-
 [profile.release]
 lto = true
 opt-level = 'z'

package/packages/enums/src/lib.rs

@@ -1,2 +1,3 @@
 pub mod batch;
 pub mod keys;
+pub mod platform;

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

@@ -0,0 +1,38 @@
+use dpp::version::PlatformVersion;
+use dpp::version::v1::PLATFORM_V1;
+use dpp::version::v2::PLATFORM_V2;
+use dpp::version::v3::PLATFORM_V3;
+use dpp::version::v4::PLATFORM_V4;
+use dpp::version::v5::PLATFORM_V5;
+use dpp::version::v6::PLATFORM_V6;
+use dpp::version::v7::PLATFORM_V7;
+use dpp::version::v8::PLATFORM_V8;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "PlatformVersionWASM")]
+#[allow(non_camel_case_types)]
+pub enum PlatformVersionWASM {
+    PLATFORM_V1,
+    PLATFORM_V2,
+    PLATFORM_V3,
+    PLATFORM_V4,
+    PLATFORM_V5,
+    PLATFORM_V6,
+    PLATFORM_V7,
+    PLATFORM_V8,
+}
+
+impl From<PlatformVersionWASM> for PlatformVersion {
+    fn from(value: PlatformVersionWASM) -> Self {
+        match value {
+            PlatformVersionWASM::PLATFORM_V1 => PLATFORM_V1,
+            PlatformVersionWASM::PLATFORM_V2 => PLATFORM_V2,
+            PlatformVersionWASM::PLATFORM_V3 => PLATFORM_V3,
+            PlatformVersionWASM::PLATFORM_V4 => PLATFORM_V4,
+            PlatformVersionWASM::PLATFORM_V5 => PLATFORM_V5,
+            PlatformVersionWASM::PLATFORM_V6 => PLATFORM_V6,
+            PlatformVersionWASM::PLATFORM_V7 => PLATFORM_V7,
+            PlatformVersionWASM::PLATFORM_V8 => PLATFORM_V8,
+        }
+    }
+}

package/packages/identity/Cargo.toml

@@ -8,9 +8,12 @@ crate-type = ["cdylib", "lib"]
 
 [dependencies]
 wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
-dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false}
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "identity-serialization"
+]}
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
 pshenmic_dpp_public_key = { path = "../public_key" }
+pshenmic_dpp_utils = { path = "../utils" }
 
 [profile.release]
 lto = true

package/packages/identity/src/lib.rs

@@ -2,8 +2,10 @@ use dpp::identifier::Identifier;
 use dpp::identity::accessors::{IdentityGettersV0, IdentitySettersV0};
 use dpp::identity::{Identity, KeyID};
 use dpp::platform_value::string_encoding::Encoding::Base58;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
 use dpp::version::PlatformVersion;
 use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
+use pshenmic_dpp_utils::WithJsError;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -13,13 +15,17 @@ pub struct IdentityWASM(Identity);
 #[wasm_bindgen]
 impl IdentityWASM {
     #[wasm_bindgen(constructor)]
-    pub fn new(js_identifier: String) -> IdentityWASM {
+    pub fn new(js_identifier: String) -> Result<IdentityWASM, JsValue> {
         let identifier = Identifier::from_string(&*js_identifier, Base58);
 
         let identity =
-            Identity::create_basic_identity(identifier.unwrap(), PlatformVersion::first()).unwrap();
+            Identity::create_basic_identity(identifier.unwrap(), PlatformVersion::first())
+                .with_js_error();
 
-        IdentityWASM(identity)
+        match identity {
+            Ok(identity) => Ok(IdentityWASM(identity)),
+            Err(err) => Err(err),
+        }
     }
 
     #[wasm_bindgen(js_name = "setId")]
@@ -72,6 +78,20 @@ impl IdentityWASM {
     #[wasm_bindgen(js_name = "getPublicKeys")]
     pub fn get_public_keys(&self) -> JsValue {
         let keys = self.0.public_keys();
+
         serde_wasm_bindgen::to_value(keys).unwrap()
     }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityWASM, JsValue> {
+        match Identity::deserialize_from_bytes(bytes.as_slice()).with_js_error() {
+            Ok(identity) => Ok(IdentityWASM(identity)),
+            Err(err) => Err(err),
+        }
+    }
 }

package/packages/identity_transitions/src/create_transition/mod.rs

@@ -64,8 +64,8 @@ impl IdentityCreateTransitionWASM {
         StateTransitionWASM::from(StateTransition::IdentityCreate(self.clone().0))
     }
 
-    #[wasm_bindgen(js_name = "toBuffer")]
-    pub fn to_buffer(&self) -> Result<JsValue, JsValue> {
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<JsValue, JsValue> {
         let bytes = self.0.serialize_to_bytes().with_js_error();
 
         match bytes {
@@ -86,8 +86,8 @@ impl IdentityCreateTransitionWASM {
         }
     }
 
-    #[wasm_bindgen(js_name = "fromBuffer")]
-    pub fn from_buffer(bytes: Vec<u8>) -> Result<IdentityCreateTransitionWASM, JsValue> {
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityCreateTransitionWASM, JsValue> {
         let rs_transition =
             IdentityCreateTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error();
 

package/packages/private_key/src/lib.rs

@@ -7,7 +7,7 @@ pub struct PrivateKeyWASM(PrivateKey);
 
 #[wasm_bindgen]
 impl PrivateKeyWASM {
-    #[wasm_bindgen(js_name = "new")]
+    #[wasm_bindgen(constructor)]
     pub fn new(wif: &str) -> Result<Self, JsValue> {
         let pk = PrivateKey::from_wif(wif).map_err(|err| JsValue::from_str(&*err.to_string()));
 

package/packages/public_key/src/lib.rs

@@ -128,16 +128,14 @@ impl IdentityPublicKeyWASM {
         self.0.set_disabled_at(disabled_at)
     }
 
-    #[wasm_bindgen(js_name = toBuffer)]
-    pub fn to_buffer(&self) -> Result<Vec<u8>, JsValue> {
+    #[wasm_bindgen(js_name = toBytes)]
+    pub fn to_byes(&self) -> Result<Vec<u8>, JsValue> {
         self.0.serialize_to_bytes().with_js_error()
     }
 
-    #[wasm_bindgen(js_name = fromBuffer)]
-    pub fn from_buffer(buffer: Vec<u8>) -> Result<IdentityPublicKeyWASM, JsValue> {
-        let rs_pk = IdentityPublicKey::deserialize_from_bytes(buffer.as_slice()).with_js_error();
-
-        match rs_pk {
+    #[wasm_bindgen(js_name = fromBytes)]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityPublicKeyWASM, JsValue> {
+        match IdentityPublicKey::deserialize_from_bytes(bytes.as_slice()).with_js_error() {
             Ok(pk) => Ok(IdentityPublicKeyWASM(pk)),
             Err(e) => Err(e),
         }

package/packages/state_transition/src/lib.rs

@@ -77,15 +77,16 @@ impl StateTransitionWASM {
         }
     }
 
-    #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self) -> Result<JsValue, JsValue> {
+    #[wasm_bindgen(js_name=toBytes)]
+    pub fn to_bytes(&self) -> Result<JsValue, JsValue> {
         let bytes = self.0.serialize_to_bytes().expect("Serialization failed");
 
         Ok(JsValue::from(bytes.clone()))
     }
 
-    pub fn from_buffer(buffer: Vec<u8>) -> Result<StateTransitionWASM, JsValue> {
-        let st = StateTransition::deserialize_from_bytes(buffer.as_slice());
+    #[wasm_bindgen(js_name=fromBytes)]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<StateTransitionWASM, JsValue> {
+        let st = StateTransition::deserialize_from_bytes(bytes.as_slice());
 
         match st {
             Err(err) => Err(JsValue::from_str(err.to_string().as_str())),

package/src/lib.rs

@@ -1,5 +1,10 @@
-pub use pshenmic_dpp_document_batch::DocumentBatchWASM;
+#![no_std]
+#![no_main]
+
+pub use pshenmic_dpp_data_contract;
+pub use pshenmic_dpp_document_batch;
 pub use pshenmic_dpp_document_search;
+pub use pshenmic_dpp_enums;
 pub use pshenmic_dpp_identity;
 pub use pshenmic_dpp_identity_transitions;
 pub use pshenmic_dpp_state_transition;