pshenmic-dpp 1.0.4 → 1.0.5

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

@@ -0,0 +1,93 @@
+use dpp::dashcore::hashes::serde::Serialize;
+use dpp::prelude::{IdentityNonce, Revision};
+use dpp::state_transition::documents_batch_transition::document_replace_transition::v0::v0_methods::DocumentReplaceTransitionV0Methods;
+use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransition;
+use dpp::state_transition::documents_batch_transition::DocumentReplaceTransition;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+use pshenmic_dpp_document::DocumentWASM;
+use pshenmic_dpp_utils::ToSerdeJSONExt;
+use crate::document_base_transition::DocumentBaseTransitionWASM;
+use crate::generators::generate_replace_transition;
+use crate::document_transition::DocumentTransitionWASM;
+
+#[wasm_bindgen(js_name = "DocumentReplaceTransitionWASM")]
+pub struct DocumentReplaceTransitionWASM(DocumentReplaceTransition);
+
+impl From<DocumentReplaceTransition> for DocumentReplaceTransitionWASM {
+    fn from(document_replace: DocumentReplaceTransition) -> Self {
+        DocumentReplaceTransitionWASM(document_replace)
+    }
+}
+
+impl From<DocumentReplaceTransitionWASM> for DocumentReplaceTransition {
+    fn from(document_replace: DocumentReplaceTransitionWASM) -> Self {
+        document_replace.0
+    }
+}
+
+#[wasm_bindgen]
+impl DocumentReplaceTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        document: &DocumentWASM,
+        identity_contract_nonce: IdentityNonce,
+        document_type_name: String,
+    ) -> Result<DocumentReplaceTransitionWASM, JsValue> {
+        let rs_update_transition = generate_replace_transition(
+            document.clone(),
+            identity_contract_nonce,
+            document_type_name.to_string(),
+        );
+
+        Ok(DocumentReplaceTransitionWASM(rs_update_transition))
+    }
+
+    #[wasm_bindgen(getter = "data")]
+    pub fn get_data(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        self.0.data().serialize(&serializer).map_err(JsValue::from)
+    }
+
+    #[wasm_bindgen(getter = "base")]
+    pub fn get_base(&self) -> DocumentBaseTransitionWASM {
+        self.0.base().clone().into()
+    }
+
+    #[wasm_bindgen(getter = "revision")]
+    pub fn get_revision(&self) -> Revision {
+        self.0.revision()
+    }
+
+    #[wasm_bindgen(setter = "data")]
+    pub fn set_data(&mut self, js_data: JsValue) -> Result<(), JsValue> {
+        let data = js_data.with_serde_to_platform_value_map()?;
+
+        Ok(self.0.set_data(data))
+    }
+
+    #[wasm_bindgen(setter = "base")]
+    pub fn set_base(&mut self, base: &DocumentBaseTransitionWASM) {
+        self.0.set_base(base.clone().into())
+    }
+
+    #[wasm_bindgen(setter = "revision")]
+    pub fn set_revision(&mut self, revision: Revision) {
+        self.0.set_revision(revision);
+    }
+
+    #[wasm_bindgen(js_name = "toDocumentTransition")]
+    pub fn to_document_transition(&self) -> DocumentTransitionWASM {
+        let rs_transition = DocumentTransition::from(self.0.clone());
+
+        DocumentTransitionWASM::from(rs_transition)
+    }
+
+    #[wasm_bindgen(js_name = "fromDocumentTransition")]
+    pub fn from_document_transition(
+        js_transition: DocumentTransitionWASM,
+    ) -> Result<DocumentReplaceTransitionWASM, JsValue> {
+        js_transition.get_replace_transition()
+    }
+}

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

@@ -0,0 +1,86 @@
+use dpp::prelude::IdentityNonce;
+use dpp::state_transition::documents_batch_transition::document_transition::document_transfer_transition::v0::v0_methods::DocumentTransferTransitionV0Methods;
+use dpp::state_transition::documents_batch_transition::document_transition::{DocumentTransferTransition, DocumentTransition};
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+use pshenmic_dpp_document::DocumentWASM;
+use pshenmic_dpp_utils::identifier_from_js_value;
+use crate::document_base_transition::DocumentBaseTransitionWASM;
+use crate::document_transition::DocumentTransitionWASM;
+use crate::generators::generate_transfer_transition;
+
+#[wasm_bindgen(js_name = "DocumentTransferTransitionWASM")]
+pub struct DocumentTransferTransitionWASM(DocumentTransferTransition);
+
+impl From<DocumentTransferTransition> for DocumentTransferTransitionWASM {
+    fn from(transition: DocumentTransferTransition) -> Self {
+        DocumentTransferTransitionWASM(transition)
+    }
+}
+
+impl From<DocumentTransferTransitionWASM> for DocumentTransferTransition {
+    fn from(transition: DocumentTransferTransitionWASM) -> Self {
+        transition.0
+    }
+}
+
+#[wasm_bindgen]
+impl DocumentTransferTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        document: &DocumentWASM,
+        identity_contract_nonce: IdentityNonce,
+        document_type_name: String,
+        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,
+        );
+
+        Ok(DocumentTransferTransitionWASM(rs_transfer_transition))
+    }
+
+    #[wasm_bindgen(getter = "base")]
+    pub fn get_base(&self) -> DocumentBaseTransitionWASM {
+        self.0.base().clone().into()
+    }
+
+    #[wasm_bindgen(getter = "recipientId")]
+    pub fn get_recipient_owner_id(&self) -> Vec<u8> {
+        self.0.recipient_owner_id().to_vec()
+    }
+
+    #[wasm_bindgen(setter = "base")]
+    pub fn set_base(&mut self, base: &DocumentBaseTransitionWASM) {
+        self.0.set_base(base.clone().into())
+    }
+
+    #[wasm_bindgen(setter = "recipientId")]
+    pub fn set_recipient_owner_id(
+        &mut self,
+        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))
+    }
+
+    #[wasm_bindgen(js_name = "toDocumentTransition")]
+    pub fn to_document_transition(&self) -> DocumentTransitionWASM {
+        let rs_transition = DocumentTransition::from(self.0.clone());
+
+        DocumentTransitionWASM::from(rs_transition)
+    }
+
+    #[wasm_bindgen(js_name = "fromDocumentTransition")]
+    pub fn from_document_transition(
+        js_transition: DocumentTransitionWASM,
+    ) -> Result<DocumentTransferTransitionWASM, JsValue> {
+        js_transition.get_transfer_transition()
+    }
+}

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

@@ -0,0 +1,75 @@
+use dpp::fee::Credits;
+use dpp::prelude::IdentityNonce;
+use dpp::state_transition::documents_batch_transition::document_transition::document_update_price_transition::v0::v0_methods::DocumentUpdatePriceTransitionV0Methods;
+use dpp::state_transition::documents_batch_transition::document_transition::{DocumentTransition, DocumentUpdatePriceTransition};
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+use pshenmic_dpp_document::DocumentWASM;
+use crate::document_base_transition::DocumentBaseTransitionWASM;
+use crate::document_transition::DocumentTransitionWASM;
+use crate::generators::generate_update_price_transition;
+
+#[wasm_bindgen(js_name = "DocumentUpdatePriceTransitionWASM")]
+pub struct DocumentUpdatePriceTransitionWASM(DocumentUpdatePriceTransition);
+
+impl From<DocumentUpdatePriceTransition> for DocumentUpdatePriceTransitionWASM {
+    fn from(document_update_price_transition: DocumentUpdatePriceTransition) -> Self {
+        DocumentUpdatePriceTransitionWASM(document_update_price_transition)
+    }
+}
+
+#[wasm_bindgen]
+impl DocumentUpdatePriceTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        document: &DocumentWASM,
+        identity_contract_nonce: IdentityNonce,
+        document_type_name: String,
+        price: Credits,
+    ) -> Result<DocumentUpdatePriceTransitionWASM, JsValue> {
+        let rs_document_update_price_transition = generate_update_price_transition(
+            document.clone(),
+            identity_contract_nonce,
+            document_type_name,
+            price,
+        );
+
+        Ok(DocumentUpdatePriceTransitionWASM(
+            rs_document_update_price_transition,
+        ))
+    }
+
+    #[wasm_bindgen(getter = "base")]
+    pub fn get_base(&self) -> DocumentBaseTransitionWASM {
+        self.0.base().clone().into()
+    }
+
+    #[wasm_bindgen(getter = "price")]
+    pub fn get_price(&self) -> Credits {
+        self.0.price()
+    }
+
+    #[wasm_bindgen(setter = "base")]
+    pub fn set_base(&mut self, base: &DocumentBaseTransitionWASM) {
+        self.0.set_base(base.clone().into())
+    }
+
+    #[wasm_bindgen(setter = "price")]
+    pub fn set_price(&mut self, price: Credits) {
+        self.0.set_price(price)
+    }
+
+    #[wasm_bindgen(js_name = "toDocumentTransition")]
+    pub fn to_document_transition(&self) -> DocumentTransitionWASM {
+        let rs_transition = DocumentTransition::from(self.0.clone());
+
+        DocumentTransitionWASM::from(rs_transition)
+    }
+
+    #[wasm_bindgen(js_name = "fromDocumentTransition")]
+    pub fn from_document_transition(
+        js_transition: DocumentTransitionWASM,
+    ) -> Result<DocumentUpdatePriceTransitionWASM, JsValue> {
+        js_transition.get_update_price_transition()
+    }
+}

package/packages/enums/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_enums"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
@@ -9,5 +9,5 @@ crate-type = ["cdylib", "lib"]
 [dependencies]
 wasm-bindgen = "0.2.100"
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
-    "identity-value-conversion",
-]}
+    "state-transitions"
+]}

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

@@ -1,19 +1,84 @@
+use dpp::state_transition::documents_batch_transition::document_transition::action_type::DocumentTransitionActionType;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name = "BatchType")]
-pub enum BatchType {
-    CREATE,
-    REPLACE,
-    DELETE,
+pub enum BatchTypeWASM {
+    Create,
+    Replace,
+    Delete,
+    Transfer,
+    Purchase,
+    UpdatePrice,
+    IgnoreWhileBumpingRevision,
 }
 
-impl From<u8> for BatchType {
-    fn from(value: u8) -> Self {
+impl TryFrom<JsValue> for BatchTypeWASM {
+    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() {
+                    "create" => Ok(BatchTypeWASM::Create),
+                    "replace" => Ok(BatchTypeWASM::Replace),
+                    "delete" => Ok(BatchTypeWASM::Delete),
+                    "transfer" => Ok(BatchTypeWASM::Transfer),
+                    "purchase" => Ok(BatchTypeWASM::Purchase),
+                    "updatePrice" => Ok(BatchTypeWASM::UpdatePrice),
+                    "ignoreWhileBumpingRevision" => Ok(BatchTypeWASM::IgnoreWhileBumpingRevision),
+                    _ => Err(JsValue::from(format!(
+                        "unknown batch type value: {}",
+                        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(BatchTypeWASM::Create),
+                    1 => Ok(BatchTypeWASM::Replace),
+                    2 => Ok(BatchTypeWASM::Delete),
+                    3 => Ok(BatchTypeWASM::Transfer),
+                    4 => Ok(BatchTypeWASM::Purchase),
+                    5 => Ok(BatchTypeWASM::UpdatePrice),
+                    6 => Ok(BatchTypeWASM::IgnoreWhileBumpingRevision),
+                    _ => Err(JsValue::from(format!(
+                        "unknown batch type value: {}",
+                        enum_val
+                    ))),
+                },
+            },
+        }
+    }
+}
+
+impl From<BatchTypeWASM> for String {
+    fn from(value: BatchTypeWASM) -> Self {
         match value {
-            0 => BatchType::CREATE,
-            1 => BatchType::REPLACE,
-            2 => BatchType::DELETE,
-            _ => panic!("Invalid BatchType"),
+            BatchTypeWASM::Create => String::from("create"),
+            BatchTypeWASM::Replace => String::from("replace"),
+            BatchTypeWASM::Delete => String::from("delete"),
+            BatchTypeWASM::Transfer => String::from("transfer"),
+            BatchTypeWASM::Purchase => String::from("purchase"),
+            BatchTypeWASM::UpdatePrice => String::from("updatePrice"),
+            BatchTypeWASM::IgnoreWhileBumpingRevision => String::from("ignoreWhileBumpingRevision"),
+        }
+    }
+}
+
+impl From<DocumentTransitionActionType> for BatchTypeWASM {
+    fn from(action_type: DocumentTransitionActionType) -> Self {
+        match action_type {
+            DocumentTransitionActionType::Create => BatchTypeWASM::Create,
+            DocumentTransitionActionType::Replace => BatchTypeWASM::Replace,
+            DocumentTransitionActionType::Delete => BatchTypeWASM::Delete,
+            DocumentTransitionActionType::Transfer => BatchTypeWASM::Transfer,
+            DocumentTransitionActionType::Purchase => BatchTypeWASM::Purchase,
+            DocumentTransitionActionType::UpdatePrice => BatchTypeWASM::UpdatePrice,
+            DocumentTransitionActionType::IgnoreWhileBumpingRevision => {
+                BatchTypeWASM::IgnoreWhileBumpingRevision
+            }
         }
     }
 }

package/packages/enums/src/keys/key_type.rs

@@ -1,4 +1,5 @@
 use dpp::identity::KeyType;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[allow(non_camel_case_types)]
@@ -11,6 +12,51 @@ pub enum KeyTypeWASM {
     EDDSA_25519_HASH160 = 4,
 }
 
+impl TryFrom<JsValue> for KeyTypeWASM {
+    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() {
+                    "ecdsa_secp256k1" => Ok(KeyTypeWASM::ECDSA_SECP256K1),
+                    "bls12_381" => Ok(KeyTypeWASM::BLS12_381),
+                    "ecdsa_hash160" => Ok(KeyTypeWASM::ECDSA_HASH160),
+                    "bip13_script_hash" => Ok(KeyTypeWASM::BIP13_SCRIPT_HASH),
+                    "eddsa_25519_hash160" => Ok(KeyTypeWASM::EDDSA_25519_HASH160),
+                    _ => Err(JsValue::from(format!("unsupported key 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(KeyTypeWASM::ECDSA_SECP256K1),
+                    1 => Ok(KeyTypeWASM::BLS12_381),
+                    2 => Ok(KeyTypeWASM::ECDSA_HASH160),
+                    3 => Ok(KeyTypeWASM::BIP13_SCRIPT_HASH),
+                    4 => Ok(KeyTypeWASM::EDDSA_25519_HASH160),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported key type ({})",
+                        enum_val
+                    ))),
+                },
+            },
+        }
+    }
+}
+
+impl From<KeyTypeWASM> for String {
+    fn from(value: KeyTypeWASM) -> Self {
+        match value {
+            KeyTypeWASM::ECDSA_SECP256K1 => String::from("ECDSA_SECP256K1"),
+            KeyTypeWASM::BLS12_381 => String::from("BLS12_381"),
+            KeyTypeWASM::ECDSA_HASH160 => String::from("ECDSA_HASH160"),
+            KeyTypeWASM::BIP13_SCRIPT_HASH => String::from("BIP13_SCRIPT_HASH"),
+            KeyTypeWASM::EDDSA_25519_HASH160 => String::from("EDDSA_25519_HASH160"),
+        }
+    }
+}
+
 impl From<KeyTypeWASM> for KeyType {
     fn from(key_type: KeyTypeWASM) -> Self {
         match key_type {

package/packages/enums/src/keys/purpose.rs

@@ -1,4 +1,5 @@
 use dpp::identity::Purpose;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name = "Purpose")]
@@ -12,6 +13,60 @@ pub enum PurposeWASM {
     OWNER = 6,
 }
 
+impl TryFrom<JsValue> for PurposeWASM {
+    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() {
+                    "authentication" => Ok(PurposeWASM::AUTHENTICATION),
+                    "encryption" => Ok(PurposeWASM::ENCRYPTION),
+                    "decryption" => Ok(PurposeWASM::DECRYPTION),
+                    "transfer" => Ok(PurposeWASM::TRANSFER),
+                    "system" => Ok(PurposeWASM::SYSTEM),
+                    "voting" => Ok(PurposeWASM::VOTING),
+                    "owner" => Ok(PurposeWASM::OWNER),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported purpose value ({})",
+                        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(PurposeWASM::AUTHENTICATION),
+                    1 => Ok(PurposeWASM::ENCRYPTION),
+                    2 => Ok(PurposeWASM::DECRYPTION),
+                    3 => Ok(PurposeWASM::TRANSFER),
+                    4 => Ok(PurposeWASM::SYSTEM),
+                    5 => Ok(PurposeWASM::VOTING),
+                    6 => Ok(PurposeWASM::OWNER),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported purpose value ({})",
+                        enum_val
+                    ))),
+                },
+            },
+        }
+    }
+}
+
+impl From<PurposeWASM> for String {
+    fn from(value: PurposeWASM) -> Self {
+        match value {
+            PurposeWASM::AUTHENTICATION => String::from("AUTHENTICATION"),
+            PurposeWASM::ENCRYPTION => String::from("ENCRYPTION"),
+            PurposeWASM::DECRYPTION => String::from("DECRYPTION"),
+            PurposeWASM::TRANSFER => String::from("TRANSFER"),
+            PurposeWASM::SYSTEM => String::from("SYSTEM"),
+            PurposeWASM::VOTING => String::from("VOTING"),
+            PurposeWASM::OWNER => String::from("OWNER"),
+        }
+    }
+}
+
 impl From<PurposeWASM> for Purpose {
     fn from(purpose: PurposeWASM) -> Self {
         match purpose {

package/packages/enums/src/keys/security_level.rs

@@ -1,4 +1,5 @@
 use dpp::identity::SecurityLevel;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name = SecurityLevel)]
@@ -9,6 +10,51 @@ pub enum SecurityLevelWASM {
     MEDIUM = 3,
 }
 
+impl TryFrom<JsValue> for SecurityLevelWASM {
+    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() {
+                    "master" => Ok(SecurityLevelWASM::MASTER),
+                    "critical" => Ok(SecurityLevelWASM::CRITICAL),
+                    "high" => Ok(SecurityLevelWASM::HIGH),
+                    "medium" => Ok(SecurityLevelWASM::MEDIUM),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported security level value ({})",
+                        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(SecurityLevelWASM::MASTER),
+                    1 => Ok(SecurityLevelWASM::CRITICAL),
+                    2 => Ok(SecurityLevelWASM::HIGH),
+                    3 => Ok(SecurityLevelWASM::MEDIUM),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported security level value ({})",
+                        enum_val
+                    ))),
+                },
+            },
+        }
+    }
+}
+
+impl From<SecurityLevelWASM> for String {
+    fn from(level: SecurityLevelWASM) -> String {
+        match level {
+            SecurityLevelWASM::MASTER => String::from("MASTER"),
+            SecurityLevelWASM::CRITICAL => String::from("CRITICAL"),
+            SecurityLevelWASM::HIGH => String::from("HIGH"),
+            SecurityLevelWASM::MEDIUM => String::from("MEDIUM"),
+        }
+    }
+}
+
 impl From<SecurityLevelWASM> for SecurityLevel {
     fn from(security_level: SecurityLevelWASM) -> Self {
         match security_level {

package/packages/enums/src/lib.rs

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

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

@@ -0,0 +1,67 @@
+use dpp::dashcore::network::constants::Network;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+#[wasm_bindgen(js_name = "NetworkWASM")]
+#[allow(non_camel_case_types)]
+pub enum NetworkWASM {
+    Mainnet = 0,
+    Testnet = 1,
+    Devnet = 2,
+    Regtest = 3,
+}
+
+impl TryFrom<JsValue> for NetworkWASM {
+    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() {
+                    "mainnet" => Ok(NetworkWASM::Mainnet),
+                    "testnet" => Ok(NetworkWASM::Testnet),
+                    "devnet" => Ok(NetworkWASM::Devnet),
+                    "regtest" => Ok(NetworkWASM::Regtest),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported network name ({})",
+                        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(NetworkWASM::Mainnet),
+                    1 => Ok(NetworkWASM::Testnet),
+                    2 => Ok(NetworkWASM::Devnet),
+                    3 => Ok(NetworkWASM::Regtest),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported network name ({})",
+                        enum_val
+                    ))),
+                },
+            },
+        }
+    }
+}
+
+impl From<NetworkWASM> for String {
+    fn from(value: NetworkWASM) -> Self {
+        match value {
+            NetworkWASM::Mainnet => "Mainnet".to_string(),
+            NetworkWASM::Testnet => "Testnet".to_string(),
+            NetworkWASM::Devnet => "Devnet".to_string(),
+            NetworkWASM::Regtest => "Regtest".to_string(),
+        }
+    }
+}
+
+impl From<NetworkWASM> for Network {
+    fn from(network: NetworkWASM) -> Self {
+        match network {
+            NetworkWASM::Mainnet => Network::Dash,
+            NetworkWASM::Testnet => Network::Testnet,
+            NetworkWASM::Devnet => Network::Devnet,
+            NetworkWASM::Regtest => Network::Regtest,
+        }
+    }
+}