pshenmic-dpp 1.0.0 → 1.0.2

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "pshenmic-dpp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "main": "dist/wasm/pshenmic_dpp.js",
   "repository": {
     "type": "git",
-    "url": "https://github.com/owl352/pshemic-dpp"
+    "url": "https://github.com/owl352/pshenmic-dpp"
   },
   "scripts": {
     "tsc": "tsc",
@@ -20,6 +20,5 @@
     "babel": "^6.23.0",
     "babel-cli": "^6.26.0",
     "typescript": "^5.8.2"
-  },
-  "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447"
+  }
 }

package/packages/cbor-conversation/Cargo.toml

@@ -9,9 +9,13 @@ 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, features = [
-    "cbor"
+    "cbor",
 ]}
 pshenmic_dpp_utils = {path = "../utils"}
 base64 = "0.22.1"
-ciborium = "0.2.0"
+ciborium = "0.2.2"
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/cbor-conversation/src/lib.rs

@@ -1,7 +1,5 @@
 use base64::Engine;
 use base64::prelude::BASE64_STANDARD;
-use ciborium;
-use ciborium::Value;
 use dpp::util::cbor_serializer::serializable_value_to_cbor;
 use pshenmic_dpp_utils::with_serde_to_platform_value;
 use wasm_bindgen::JsValue;
@@ -20,7 +18,7 @@ pub fn object_to_cbor(object: &JsValue) -> String {
 pub fn cbor_to_object(cbor: String) -> JsValue {
     let base64_bytes = BASE64_STANDARD.decode(cbor).unwrap();
 
-    let cbor: Value = ciborium::de::from_reader(base64_bytes.as_slice()).expect("REASON");
+    let cbor: ciborium::Value = ciborium::de::from_reader(base64_bytes.as_slice()).expect("REASON");
 
     serde_wasm_bindgen::to_value(&cbor).unwrap()
 }

package/packages/document/Cargo.toml

@@ -13,3 +13,7 @@ dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-
     "document-json-conversion"
 ]}
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/document_batch/Cargo.toml

@@ -10,11 +10,15 @@ crate-type = ["cdylib", "lib"]
 wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 pshenmic_dpp_document = {path = "../document"}
 pshenmic_dpp_enums = {path = "../enums"}
-pshenmic_dpp_public_key = {path = "../public_key"}
-pshenmic_dpp_private_key = {path = "../private_key"}
 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"
 ]}
+
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/document_batch/src/lib.rs

@@ -2,12 +2,10 @@ use crate::generators::{
     generate_create_transition, generate_delete_transition, generate_replace_transition,
 };
 use dpp::document::{Document, DocumentV0};
-use dpp::identity::KeyType;
 use dpp::prelude::IdentityNonce;
 use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
 use dpp::state_transition::documents_batch_transition::accessors::DocumentsBatchTransitionAccessorsV0;
 use dpp::state_transition::documents_batch_transition::document_base_transition::v0::v0_methods::DocumentBaseTransitionV0Methods;
-use dpp::state_transition::documents_batch_transition::document_create_transition::v0::v0_methods::DocumentCreateTransitionV0Methods;
 use dpp::state_transition::documents_batch_transition::document_transition::{
     DocumentTransition, DocumentTransitionV0Methods,
 };
@@ -15,13 +13,10 @@ use dpp::state_transition::documents_batch_transition::{
     DocumentCreateTransition, DocumentDeleteTransition, DocumentReplaceTransition,
     DocumentsBatchTransition, DocumentsBatchTransitionV0,
 };
-use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned, StateTransitionLike};
+use dpp::state_transition::{StateTransition, StateTransitionLike};
 use pshenmic_dpp_document::DocumentWASM;
 use pshenmic_dpp_enums::batch::batch_enum::BatchType;
-use pshenmic_dpp_enums::keys::key_type::KeyTypeWASM;
-use pshenmic_dpp_mock_bls::MockBLS;
-use pshenmic_dpp_private_key::PrivateKeyWASM;
-use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
 use pshenmic_dpp_utils::WithJsError;
 use std::collections::BTreeMap;
 use wasm_bindgen::JsValue;
@@ -36,6 +31,56 @@ pub struct DocumentBatchWASM {
     document: DocumentWASM,
 }
 
+impl From<(DocumentTransition, DocumentsBatchTransition)> for DocumentBatchWASM {
+    fn from(
+        (document_transition, batch): (DocumentTransition, DocumentsBatchTransition),
+    ) -> DocumentBatchWASM {
+        let data_contract_id = document_transition.base().data_contract_id();
+        let document_type_name = document_transition.base().document_type_name();
+        let entropy = document_transition.entropy();
+
+        let default = BTreeMap::new();
+        let properties = document_transition.data().unwrap_or(&default);
+
+        let document = DocumentV0 {
+            id: document_transition.get_id(),
+            owner_id: batch.owner_id(),
+            properties: properties.clone(),
+            revision: document_transition.revision(),
+            created_at: None,
+            updated_at: None,
+            transferred_at: None,
+            created_at_block_height: None,
+            updated_at_block_height: None,
+            transferred_at_block_height: None,
+            created_at_core_block_height: None,
+            updated_at_core_block_height: None,
+            transferred_at_core_block_height: None,
+        };
+
+        let normal_entropy = match entropy {
+            Some(entropy) => {
+                let mut entropy_sized = [0u8; 32];
+                let bytes = entropy.as_slice();
+                let len = bytes.len().min(32);
+                entropy_sized[..len].copy_from_slice(&bytes[..len]);
+                Some(entropy_sized)
+            }
+            None => None,
+        };
+
+        DocumentBatchWASM {
+            batch: batch.clone(),
+            document: DocumentWASM::from_batch(
+                Document::V0(document),
+                data_contract_id,
+                document_type_name.to_string(),
+                normal_entropy,
+            ),
+        }
+    }
+}
+
 #[wasm_bindgen]
 impl DocumentBatchWASM {
     #[wasm_bindgen(js_name=new)]
@@ -110,207 +155,63 @@ impl DocumentBatchWASM {
             None => wasm_bindgen::throw_str("Entropy is empty"),
         }
     }
-    #[wasm_bindgen(js_name=sign)]
-    pub fn sign(
-        &mut self,
-        private_key: PrivateKeyWASM,
-        public_key: IdentityPublicKeyWASM,
-    ) -> Result<JsValue, JsValue> {
-        let mut st = StateTransition::from(self.batch.clone());
 
-        let sig = st.sign(
-            &public_key.get_key(),
-            private_key.get_key().to_bytes().as_slice(),
-            &MockBLS {},
-        );
+    #[wasm_bindgen(js_name=toStateTransition)]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        let st = StateTransition::from(self.batch.clone());
 
-        let bytes = match sig {
-            Ok(_sig) => {
-                self.batch.set_signature(st.signature().clone());
-                self.batch
-                    .set_signature_public_key_id(st.signature_public_key_id().unwrap());
-                st.serialize_to_bytes()
-            }
-            Err(e) => wasm_bindgen::throw_str(&e.to_string()),
-        };
+        StateTransitionWASM::from(st)
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self) -> Result<JsValue, JsValue> {
+        let bytes = self.batch.serialize_to_bytes().with_js_error();
 
         match bytes {
             Ok(bytes) => Ok(JsValue::from(bytes.clone())),
-            Err(e) => Ok(JsValue::from_str(&format!("{}", e))),
+            Err(err) => Err(err),
         }
     }
 
-    #[wasm_bindgen(js_name=signByPrivateKey)]
-    pub fn sign_by_private_key(
-        &mut self,
-        private_key: PrivateKeyWASM,
-        key_type: KeyTypeWASM,
-    ) -> JsValue {
-        let mut st = StateTransition::from(self.batch.clone());
-
-        let _sig = st
-            .sign_by_private_key(
-                &private_key.get_key().to_bytes().as_slice(),
-                KeyType::from(key_type),
-                &MockBLS {},
-            )
-            .with_js_error();
-
-        self.batch.set_signature(st.signature().clone());
-        self.batch
-            .set_signature_public_key_id(st.signature_public_key_id().unwrap());
+    #[wasm_bindgen(js_name=fromStateTransition)]
+    pub fn from_state_transition(
+        state_transition: StateTransitionWASM,
+    ) -> Result<DocumentBatchWASM, JsValue> {
+        let rs_st = StateTransition::from(state_transition);
 
-        let bytes = st.serialize_to_bytes().with_js_error();
+        match rs_st {
+            StateTransition::DocumentsBatch(batch) => {
+                let transition = batch.transitions().first();
 
-        match bytes {
-            Ok(bytes) => JsValue::from(bytes.clone()),
-            Err(err) => err,
+                match transition {
+                    None => Err(JsValue::from_str("No transition")),
+                    Some(document_transition) => Ok(DocumentBatchWASM::from((
+                        document_transition.clone(),
+                        batch,
+                    ))),
+                }
+            }
+            _ => Err(JsValue::from_str("Invalid state transition")),
         }
     }
 
-    #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self) -> Result<JsValue, JsValue> {
-        let bytes = &StateTransition::from(self.batch.clone())
-            .serialize_to_bytes()
-            .expect("Serialization failed");
-
-        Ok(JsValue::from(bytes.clone()))
-    }
-
-    #[wasm_bindgen(js_name=fromBuffer)]
     pub fn from_buffer(bytes: Vec<u8>) -> Result<DocumentBatchWASM, JsValue> {
-        let batch = &StateTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error()?;
+        let batch_transition =
+            DocumentsBatchTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error();
 
-        match batch {
-            StateTransition::DocumentsBatch(batch) => {
+        match batch_transition {
+            Ok(batch) => {
                 let transition = batch.transitions().first();
 
                 match transition {
                     None => Err(JsValue::from_str("No transition")),
-                    Some(document_transition) => {
-                        let data_contract_id = document_transition.base().data_contract_id();
-                        let document_type_name = document_transition.base().document_type_name();
-                        let entropy = document_transition.entropy();
-
-                        let document: DocumentV0 = match document_transition {
-                            DocumentTransition::Create(create_transition) => DocumentV0 {
-                                id: document_transition.get_id(),
-                                owner_id: batch.owner_id(),
-                                properties: create_transition.data().clone(),
-                                revision: document_transition.revision(),
-                                created_at: None,
-                                updated_at: None,
-                                transferred_at: None,
-                                created_at_block_height: None,
-                                updated_at_block_height: None,
-                                transferred_at_block_height: None,
-                                created_at_core_block_height: None,
-                                updated_at_core_block_height: None,
-                                transferred_at_core_block_height: None,
-                            },
-                            DocumentTransition::Replace(_replace_transition) => DocumentV0 {
-                                id: document_transition.get_id(),
-                                owner_id: batch.owner_id(),
-                                properties: BTreeMap::new(),
-                                revision: document_transition.revision(),
-                                created_at: None,
-                                updated_at: None,
-                                transferred_at: None,
-                                created_at_block_height: None,
-                                updated_at_block_height: None,
-                                transferred_at_block_height: None,
-                                created_at_core_block_height: None,
-                                updated_at_core_block_height: None,
-                                transferred_at_core_block_height: None,
-                            },
-                            DocumentTransition::Delete(_delete_transition) => DocumentV0 {
-                                id: document_transition.get_id(),
-                                owner_id: batch.owner_id(),
-                                properties: BTreeMap::new(),
-                                revision: document_transition.revision(),
-                                created_at: None,
-                                updated_at: None,
-                                transferred_at: None,
-                                created_at_block_height: None,
-                                updated_at_block_height: None,
-                                transferred_at_block_height: None,
-                                created_at_core_block_height: None,
-                                updated_at_core_block_height: None,
-                                transferred_at_core_block_height: None,
-                            },
-                            DocumentTransition::Transfer(_transfer_transition) => DocumentV0 {
-                                id: document_transition.get_id(),
-                                owner_id: batch.owner_id(),
-                                properties: BTreeMap::new(),
-                                revision: document_transition.revision(),
-                                created_at: None,
-                                updated_at: None,
-                                transferred_at: None,
-                                created_at_block_height: None,
-                                updated_at_block_height: None,
-                                transferred_at_block_height: None,
-                                created_at_core_block_height: None,
-                                updated_at_core_block_height: None,
-                                transferred_at_core_block_height: None,
-                            },
-                            DocumentTransition::UpdatePrice(_update_price_transition) => {
-                                DocumentV0 {
-                                    id: document_transition.get_id(),
-                                    owner_id: batch.owner_id(),
-                                    properties: BTreeMap::new(),
-                                    revision: document_transition.revision(),
-                                    created_at: None,
-                                    updated_at: None,
-                                    transferred_at: None,
-                                    created_at_block_height: None,
-                                    updated_at_block_height: None,
-                                    transferred_at_block_height: None,
-                                    created_at_core_block_height: None,
-                                    updated_at_core_block_height: None,
-                                    transferred_at_core_block_height: None,
-                                }
-                            }
-                            DocumentTransition::Purchase(_purchase_transition) => DocumentV0 {
-                                id: document_transition.get_id(),
-                                owner_id: batch.owner_id(),
-                                properties: BTreeMap::new(),
-                                revision: document_transition.revision(),
-                                created_at: None,
-                                updated_at: None,
-                                transferred_at: None,
-                                created_at_block_height: None,
-                                updated_at_block_height: None,
-                                transferred_at_block_height: None,
-                                created_at_core_block_height: None,
-                                updated_at_core_block_height: None,
-                                transferred_at_core_block_height: None,
-                            },
-                        };
-
-                        let normal_entropy = match entropy {
-                            Some(entropy) => {
-                                let mut entropy_sized = [0u8; 32];
-                                let bytes = entropy.as_slice();
-                                let len = bytes.len().min(32);
-                                entropy_sized[..len].copy_from_slice(&bytes[..len]);
-                                Some(entropy_sized)
-                            }
-                            None => None,
-                        };
-
-                        Ok(DocumentBatchWASM {
-                            batch: batch.clone(),
-                            document: DocumentWASM::from_batch(
-                                Document::V0(document),
-                                data_contract_id,
-                                document_type_name.to_string(),
-                                normal_entropy,
-                            ),
-                        })
-                    }
+                    Some(document_transition) => Ok(DocumentBatchWASM::from((
+                        document_transition.clone(),
+                        batch,
+                    ))),
                 }
             }
-            _ => Err(JsValue::from_str("incorrect batch type")),
+            Err(err) => Err(err),
         }
     }
 

package/packages/enums/Cargo.toml

@@ -10,4 +10,8 @@ crate-type = ["cdylib", "lib"]
 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/identity/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "pshenmic_dpp_identity"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+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}
+serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
+pshenmic_dpp_public_key = { path = "../public_key" }
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/identity/src/lib.rs

@@ -0,0 +1,77 @@
+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::version::PlatformVersion;
+use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "IdentityWASM")]
+pub struct IdentityWASM(Identity);
+
+#[wasm_bindgen]
+impl IdentityWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(js_identifier: String) -> IdentityWASM {
+        let identifier = Identifier::from_string(&*js_identifier, Base58);
+
+        let identity =
+            Identity::create_basic_identity(identifier.unwrap(), PlatformVersion::first()).unwrap();
+
+        IdentityWASM(identity)
+    }
+
+    #[wasm_bindgen(js_name = "setId")]
+    pub fn set_id(&mut self, js_identifier: String) {
+        let identifier = Identifier::from_string(&*js_identifier, Base58).unwrap();
+
+        self.0.set_id(identifier);
+    }
+
+    #[wasm_bindgen(js_name = "setBalance")]
+    pub fn set_balance(&mut self, balance: u64) {
+        self.0.set_balance(balance);
+    }
+
+    #[wasm_bindgen(js_name = "setRevision")]
+    pub fn set_revision(&mut self, revision: u64) {
+        self.0.set_revision(revision);
+    }
+
+    #[wasm_bindgen(js_name = "addPublicKey")]
+    pub fn set_public_key(&mut self, public_key: IdentityPublicKeyWASM) {
+        self.0.add_public_key(public_key.into());
+    }
+
+    // GETTERS
+
+    #[wasm_bindgen(js_name = "getId")]
+    pub fn get_id(&self) -> String {
+        let id = self.0.id();
+
+        id.to_string(Base58)
+    }
+
+    #[wasm_bindgen(js_name = "getBalance")]
+    pub fn get_balance(&self) -> u64 {
+        self.0.balance()
+    }
+
+    #[wasm_bindgen(js_name = "getRevision")]
+    pub fn get_revision(&self) -> u64 {
+        self.0.revision()
+    }
+
+    #[wasm_bindgen(js_name = "getPublicKeyById")]
+    pub fn get_public_key_by_id(&self, key_id: KeyID) -> IdentityPublicKeyWASM {
+        let identity_public_key = self.0.get_public_key_by_id(key_id);
+        IdentityPublicKeyWASM::from(identity_public_key.unwrap().clone())
+    }
+
+    #[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()
+    }
+}

package/packages/identity_transitions/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "pshenmic_dpp_identity_transitions"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+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, features = [
+    "state-transition-signing"
+]}
+pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_public_key = {path = "../public_key"}
+pshenmic_dpp_state_transition = {path = "../state_transition"}
+pshenmic_dpp_enums = {path = "../enums"}
+
+[profile.release]
+lto = true
+opt-level = 'z'

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

@@ -0,0 +1,99 @@
+mod public_key_in_creation;
+
+use dpp::platform_value::string_encoding::Encoding::Base58;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::state_transition::identity_create_transition::IdentityCreateTransition;
+use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0;
+use dpp::state_transition::{StateTransition, StateTransitionLike};
+use dpp::version::PlatformVersion;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::WithJsError;
+use public_key_in_creation::IdentityPublicKeyInCreationWASM;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = IdentityCreateTransitionWASM)]
+#[derive(Clone)]
+pub struct IdentityCreateTransitionWASM(IdentityCreateTransition);
+
+impl From<IdentityCreateTransition> for IdentityCreateTransitionWASM {
+    fn from(val: IdentityCreateTransition) -> Self {
+        IdentityCreateTransitionWASM(val)
+    }
+}
+
+impl From<IdentityCreateTransitionWASM> for IdentityCreateTransition {
+    fn from(val: IdentityCreateTransitionWASM) -> Self {
+        val.0
+    }
+}
+
+#[wasm_bindgen]
+impl IdentityCreateTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(platform_version: u32) -> Result<IdentityCreateTransitionWASM, JsValue> {
+        let platform_version =
+            &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
+
+        IdentityCreateTransition::default_versioned(platform_version)
+            .map(Into::into)
+            .map_err(|err| JsValue::from_str(&*err.to_string()))
+    }
+
+    #[wasm_bindgen(js_name = "defaultVersioned")]
+    pub fn get_public_keys(&self) -> Vec<IdentityPublicKeyInCreationWASM> {
+        self.0
+            .public_keys()
+            .iter()
+            .map(|key| IdentityPublicKeyInCreationWASM::from(key.clone()))
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = "getIdentifier")]
+    pub fn get_identity_id(&self) -> String {
+        self.0.identity_id().to_string(Base58)
+    }
+
+    #[wasm_bindgen(js_name = "getUserFeeIncrease")]
+    pub fn get_user_fee_increase(&self) -> u16 {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        StateTransitionWASM::from(StateTransition::IdentityCreate(self.clone().0))
+    }
+
+    #[wasm_bindgen(js_name = "toBuffer")]
+    pub fn to_buffer(&self) -> Result<JsValue, JsValue> {
+        let bytes = self.0.serialize_to_bytes().with_js_error();
+
+        match bytes {
+            Ok(bytes) => Ok(JsValue::from(bytes.clone())),
+            Err(err) => Err(err),
+        }
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        st: StateTransitionWASM,
+    ) -> Result<IdentityCreateTransitionWASM, JsValue> {
+        let rs_st: StateTransition = st.into();
+
+        match rs_st {
+            StateTransition::IdentityCreate(st) => Ok(IdentityCreateTransitionWASM(st)),
+            _ => Err(JsValue::from_str(&"Invalid state transition type)")),
+        }
+    }
+
+    #[wasm_bindgen(js_name = "fromBuffer")]
+    pub fn from_buffer(bytes: Vec<u8>) -> Result<IdentityCreateTransitionWASM, JsValue> {
+        let rs_transition =
+            IdentityCreateTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error();
+
+        match rs_transition {
+            Ok(rs_st) => Ok(IdentityCreateTransitionWASM(rs_st)),
+            Err(err) => Err(err),
+        }
+    }
+}