refactor(sdk): conventional naming to/from methods

packages/wasm-dpp2/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wasm-dpp2"
-version = "1.0.5"
+version = { workspace = true }
 edition = "2024"
 
 [lib]
@@ -16,6 +16,7 @@ dpp = { path = "../rs-dpp", default-features = false, features = [
     "document-json-conversion",
     "identity-serialization",
     "identity-value-conversion",
+    "identity-json-conversion",
     "data-contract-json-conversion",
     "document-value-conversion",
     "bls-signatures",

packages/wasm-dpp2/src/asset_lock_proof/outpoint.rs

@@ -77,7 +77,7 @@ impl OutPointWasm {
         encode(slice.as_slice(), Hex)
     }
 
-    #[wasm_bindgen(js_name = "base64")]
+    #[wasm_bindgen(js_name = "toBase64")]
     pub fn to_base64(&self) -> String {
         let slice: [u8; 36] = self.0.into();
 

packages/wasm-dpp2/src/asset_lock_proof/proof.rs

@@ -6,8 +6,12 @@ use crate::enums::lock_types::AssetLockProofTypeWasm;
 use crate::error::{WasmDppError, WasmDppResult};
 use crate::identifier::IdentifierWasm;
 use crate::utils::{IntoWasm, get_class_type};
+use dpp::platform_value::Value;
 use dpp::prelude::AssetLockProof;
 use serde::Serialize;
+use serde_json::Value as JsonValue;
+use serde_wasm_bindgen::from_value;
+use std::convert::TryFrom;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -148,6 +152,20 @@ impl AssetLockProofWasm {
             .map_err(|e| WasmDppError::serialization(e.to_string()))
     }
 
+    #[wasm_bindgen(js_name = "fromObject")]
+    pub fn from_object(js_value: JsValue) -> WasmDppResult<AssetLockProofWasm> {
+        let json_value: JsonValue =
+            from_value(js_value).map_err(|err| WasmDppError::serialization(err.to_string()))?;
+        let value = Value::from(json_value);
+        let proof = AssetLockProof::try_from(value).map_err(WasmDppError::from)?;
+        Ok(AssetLockProofWasm(proof))
+    }
+
+    #[wasm_bindgen(js_name = "fromJSON")]
+    pub fn from_json(js_value: JsValue) -> WasmDppResult<AssetLockProofWasm> {
+        AssetLockProofWasm::from_object(js_value)
+    }
+
     #[wasm_bindgen(js_name = "toHex")]
     pub fn to_string(&self) -> WasmDppResult<String> {
         let json = serde_json::to_string(&self.0)

packages/wasm-dpp2/src/core_script.rs

@@ -42,39 +42,42 @@ impl CoreScriptWasm {
     }
 
     #[wasm_bindgen(js_name = "newP2PKH")]
-    pub fn new_p2pkh(js_key_hash: Vec<u8>) -> Self {
-        let mut key_hash = [0u8; 20];
-        let bytes = js_key_hash.as_slice();
+    pub fn new_p2pkh(key_hash: Vec<u8>) -> Self {
+        let mut key_hash_bytes = [0u8; 20];
+        let bytes = key_hash.as_slice();
         let len = bytes.len().min(32);
-        key_hash[..len].copy_from_slice(&bytes[..len]);
+        key_hash_bytes[..len].copy_from_slice(&bytes[..len]);
 
-        CoreScriptWasm(CoreScript::new_p2pkh(key_hash))
+        CoreScriptWasm(CoreScript::new_p2pkh(key_hash_bytes))
     }
 
     #[wasm_bindgen(js_name = "newP2SH")]
-    pub fn new_p2sh(js_script_hash: Vec<u8>) -> Self {
-        let mut script_hash = [0u8; 20];
-        let bytes = js_script_hash.as_slice();
+    pub fn new_p2sh(script_hash: Vec<u8>) -> Self {
+        let mut script_hash_bytes = [0u8; 20];
+        let bytes = script_hash.as_slice();
         let len = bytes.len().min(32);
-        script_hash[..len].copy_from_slice(&bytes[..len]);
+        script_hash_bytes[..len].copy_from_slice(&bytes[..len]);
 
         let mut bytes = vec![
             opcodes::all::OP_HASH160.to_u8(),
             opcodes::all::OP_PUSHBYTES_20.to_u8(),
         ];
-        bytes.extend_from_slice(&script_hash);
+        bytes.extend_from_slice(&script_hash_bytes);
         bytes.push(opcodes::all::OP_EQUAL.to_u8());
         Self::from_bytes(bytes)
     }
 
     #[wasm_bindgen(js_name = "toAddress")]
-    pub fn to_address(&self, js_network: &JsValue) -> WasmDppResult<String> {
-        let network = NetworkWasm::try_from(js_network.clone())?;
+    pub fn to_address(
+        &self,
+        #[wasm_bindgen(unchecked_param_type = "Network | string")] network: &JsValue,
+    ) -> WasmDppResult<String> {
+        let network_wasm = NetworkWasm::try_from(network.clone())?;
 
         let payload = Payload::from_script(self.0.as_script())
             .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?;
 
-        let address = Address::new(network.into(), payload);
+        let address = Address::new(network_wasm.into(), payload);
 
         Ok(address.to_string())
     }
@@ -94,7 +97,7 @@ impl CoreScriptWasm {
         encode(self.0.to_bytes().as_slice(), Hex)
     }
 
-    #[wasm_bindgen(js_name = "base64")]
+    #[wasm_bindgen(js_name = "toBase64")]
     pub fn to_base64(&self) -> String {
         encode(self.0.to_bytes().as_slice(), Base64)
     }

packages/wasm-dpp2/src/data_contract/model.rs

@@ -27,6 +27,7 @@ use dpp::serialization::{
 };
 use dpp::version::PlatformVersion;
 use js_sys::{Object, Reflect};
+use serde_json::Value as JsonValue;
 use std::collections::BTreeMap;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
@@ -108,7 +109,7 @@ impl DataContractWasm {
 
         let owner_id: IdentifierWasm = js_owner_id.clone().try_into()?;
 
-        let owner_id_value = Value::from(owner_id.get_base58());
+        let owner_id_value = Value::from(owner_id.to_base58());
 
         let schema: Value = serde_wasm_bindgen::from_value(js_schema)
             .map_err(|err| WasmDppError::serialization(err.to_string()))?;
@@ -196,8 +197,8 @@ impl DataContractWasm {
         Ok(DataContractWasm(data_contract_with_tokens))
     }
 
-    #[wasm_bindgen(js_name = "fromValue")]
-    pub fn from_value(
+    #[wasm_bindgen(js_name = "fromJSON")]
+    pub fn from_json(
         js_value: JsValue,
         full_validation: bool,
         js_platform_version: JsValue,
@@ -207,9 +208,37 @@ impl DataContractWasm {
             false => PlatformVersionWasm::try_from(js_platform_version)?,
         };
 
-        let value = js_value.with_serde_to_platform_value()?;
+        let json_value: JsonValue = serde_wasm_bindgen::from_value(js_value).map_err(|err| {
+            WasmDppError::serialization(format!(
+                "unable to deserialize JSON value for DataContract.fromJSON: {}",
+                err
+            ))
+        })?;
 
-        let contract = DataContract::from_value(value, full_validation, &platform_version.into())?;
+        let contract =
+            DataContract::from_json(json_value, full_validation, &platform_version.into())
+                .map_err(WasmDppError::from)?;
+
+        Ok(DataContractWasm(contract))
+    }
+
+    #[wasm_bindgen(js_name = "fromObject")]
+    pub fn from_object(
+        js_value: JsValue,
+        full_validation: bool,
+        js_platform_version: JsValue,
+    ) -> WasmDppResult<DataContractWasm> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWasm::default(),
+            false => PlatformVersionWasm::try_from(js_platform_version)?,
+        };
+
+        let json_value: JsonValue = serde_wasm_bindgen::from_value(js_value)
+            .map_err(|err| WasmDppError::serialization(err.to_string()))?;
+
+        let contract =
+            DataContract::from_json(json_value, full_validation, &platform_version.into())
+                .map_err(WasmDppError::from)?;
 
         Ok(DataContractWasm(contract))
     }
@@ -275,22 +304,22 @@ impl DataContractWasm {
         Ok(encode(self.to_bytes(js_platform_version)?.as_slice(), Hex))
     }
 
-    #[wasm_bindgen(js_name = "base64")]
+    #[wasm_bindgen(js_name = "toBase64")]
     pub fn to_base64(&self, js_platform_version: JsValue) -> WasmDppResult<String> {
         Ok(encode(
             self.to_bytes(js_platform_version)?.as_slice(),
             Base64,
         ))
     }
 
-    #[wasm_bindgen(js_name = "toValue")]
-    pub fn to_value(&self, js_platform_version: JsValue) -> WasmDppResult<JsValue> {
+    #[wasm_bindgen(js_name = "toObject")]
+    pub fn to_object(&self, js_platform_version: JsValue) -> WasmDppResult<JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
             true => PlatformVersionWasm::default(),
             false => PlatformVersionWasm::try_from(js_platform_version)?,
         };
 
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let serializer = serde_wasm_bindgen::Serializer::default();
 
         self.0
             .clone()

packages/wasm-dpp2/src/data_contract/transitions/create.rs

@@ -101,7 +101,7 @@ impl DataContractCreateTransitionWasm {
         Ok(encode(self.to_bytes()?.as_slice(), Hex))
     }
 
-    #[wasm_bindgen(js_name = "base64")]
+    #[wasm_bindgen(js_name = "toBase64")]
     pub fn to_base64(&self) -> WasmDppResult<String> {
         Ok(encode(self.to_bytes()?.as_slice(), Base64))
     }

packages/wasm-dpp2/src/data_contract/transitions/update.rs

@@ -88,7 +88,7 @@ impl DataContractUpdateTransitionWasm {
         Ok(encode(self.to_bytes()?.as_slice(), Hex))
     }
 
-    #[wasm_bindgen(js_name = "base64")]
+    #[wasm_bindgen(js_name = "toBase64")]
     pub fn to_base64(&self) -> WasmDppResult<String> {
         Ok(encode(self.to_bytes()?.as_slice(), Base64))
     }

packages/wasm-dpp2/src/epoch/finalized_epoch_info.rs

@@ -272,9 +272,9 @@ impl FinalizedEpochInfoWasm {
     }
 
     #[wasm_bindgen(setter = "blockProposers")]
-    pub fn set_block_proposers(&mut self, js_block_proposers: &JsValue) -> WasmDppResult<()> {
-        let block_proposers = block_proposers_from_js(js_block_proposers)?;
-        self.v0_mut().block_proposers = block_proposers;
+    pub fn set_block_proposers(&mut self, block_proposers: &JsValue) -> WasmDppResult<()> {
+        let block_proposers_map = block_proposers_from_js(block_proposers)?;
+        self.v0_mut().block_proposers = block_proposers_map;
         Ok(())
     }
 

packages/wasm-dpp2/src/identifier.rs

@@ -113,18 +113,18 @@ impl IdentifierWasm {
     #[wasm_bindgen(constructor)]
     pub fn new(
         #[wasm_bindgen(unchecked_param_type = "Identifier | Uint8Array | string")]
-        js_identifier: &JsValue,
+        identifier: &JsValue,
     ) -> WasmDppResult<IdentifierWasm> {
-        IdentifierWasm::try_from(js_identifier)
+        IdentifierWasm::try_from(identifier)
     }
 
-    #[wasm_bindgen(js_name = "base58")]
-    pub fn get_base58(&self) -> String {
+    #[wasm_bindgen(js_name = "toBase58")]
+    pub fn to_base58(&self) -> String {
         self.0.to_string(Base58)
     }
 
-    #[wasm_bindgen(js_name = "base64")]
-    pub fn get_base64(&self) -> String {
+    #[wasm_bindgen(js_name = "toBase64")]
+    pub fn to_base64(&self) -> String {
         self.0.to_string(Base64)
     }