pshenmic-dpp 1.0.5 → 1.0.6

package/packages/asset_lock_proof/src/lib.rs

@@ -0,0 +1,133 @@
+pub mod chain;
+pub mod instant;
+pub mod outpoint;
+mod tx_out;
+
+use crate::chain::ChainAssetLockProofWASM;
+use crate::instant::InstantAssetLockProofWASM;
+use dpp::identity::state_transition::asset_lock_proof::InstantAssetLockProof;
+
+use crate::outpoint::OutPointWASM;
+use dpp::prelude::AssetLockProof;
+use pshenmic_dpp_enums::lock_types::AssetLockProofTypeWASM;
+use pshenmic_dpp_utils::WithJsError;
+use serde::Serialize;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "AssetLockProofWASM")]
+#[derive(Clone)]
+pub struct AssetLockProofWASM(AssetLockProof);
+
+impl From<AssetLockProofWASM> for AssetLockProof {
+    fn from(proof: AssetLockProofWASM) -> Self {
+        proof.0
+    }
+}
+
+impl From<AssetLockProof> for AssetLockProofWASM {
+    fn from(proof: AssetLockProof) -> Self {
+        AssetLockProofWASM(proof)
+    }
+}
+
+impl From<ChainAssetLockProofWASM> for AssetLockProofWASM {
+    fn from(proof: ChainAssetLockProofWASM) -> Self {
+        AssetLockProofWASM(AssetLockProof::Chain(proof.into()))
+    }
+}
+
+impl From<InstantAssetLockProofWASM> for AssetLockProofWASM {
+    fn from(proof: InstantAssetLockProofWASM) -> Self {
+        AssetLockProofWASM(AssetLockProof::Instant(proof.into()))
+    }
+}
+
+impl From<AssetLockProof> for ChainAssetLockProofWASM {
+    fn from(proof: AssetLockProof) -> ChainAssetLockProofWASM {
+        match proof {
+            AssetLockProof::Chain(chain) => ChainAssetLockProofWASM::from(chain),
+            _ => panic!("invalid asset lock proof. must contains chain lock"),
+        }
+    }
+}
+
+impl From<AssetLockProof> for InstantAssetLockProofWASM {
+    fn from(proof: AssetLockProof) -> InstantAssetLockProofWASM {
+        match proof {
+            AssetLockProof::Instant(instant) => InstantAssetLockProofWASM::from(instant),
+            _ => panic!("invalid asset lock proof. must contains chain lock"),
+        }
+    }
+}
+
+#[wasm_bindgen]
+impl AssetLockProofWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(js_asset_lock_proof_type: JsValue) -> Result<AssetLockProofWASM, JsValue> {
+        let asset_lock_proof_type = AssetLockProofTypeWASM::try_from(js_asset_lock_proof_type)?;
+
+        match asset_lock_proof_type {
+            AssetLockProofTypeWASM::Chain => Err(JsValue::from_str(&"ChainLock unavailable")),
+            AssetLockProofTypeWASM::Instant => {
+                Ok(InstantAssetLockProofWASM::from(InstantAssetLockProof::default()).into())
+            }
+        }
+    }
+
+    #[wasm_bindgen(js_name = "createInstantAssetLockProof")]
+    pub fn new_instant_asset_lock_proof(
+        instant_lock: Vec<u8>,
+        transaction: Vec<u8>,
+        output_index: u32,
+    ) -> Result<AssetLockProofWASM, JsValue> {
+        Ok(InstantAssetLockProofWASM::new(instant_lock, transaction, output_index)?.into())
+    }
+
+    #[wasm_bindgen(js_name = "createChainAssetLockProof")]
+    pub fn new_chain_asset_lock_proof(
+        core_chain_locked_height: u32,
+        out_point: &OutPointWASM,
+    ) -> Result<AssetLockProofWASM, JsValue> {
+        Ok(ChainAssetLockProofWASM::new(core_chain_locked_height, out_point)?.into())
+    }
+
+    // #[wasm_bindgen(js_name = "fromRawObject")]
+    // pub fn from_raw_object(raw_asset_lock_proof: JsValue) -> Result<AssetLockProofWASM, JsValue> {
+    //     let lock_type = get_type_from_raw_asset_lock_proof(&raw_asset_lock_proof)?;
+    //
+    //     match lock_type {
+    //         AssetLockProofTypeWASM::Instant => {
+    //             Ok(InstantAssetLockProofWASM::from_raw_value(raw_asset_lock_proof)?.into())
+    //         }
+    //         AssetLockProofTypeWASM::Chain => {
+    //             Ok(ChainAssetLockProofWASM::from_raw_value(raw_asset_lock_proof)?.into())
+    //         }
+    //     }
+    // }
+
+    #[wasm_bindgen(js_name = "getLockType")]
+    pub fn get_lock_type(&self) -> String {
+        match self.0 {
+            AssetLockProof::Chain(_) => AssetLockProofTypeWASM::Chain.into(),
+            AssetLockProof::Instant(_) => AssetLockProofTypeWASM::Instant.into(),
+        }
+    }
+
+    #[wasm_bindgen(js_name = "getInstantLockProof")]
+    pub fn get_instant_lock(&self) -> InstantAssetLockProofWASM {
+        self.clone().0.into()
+    }
+
+    #[wasm_bindgen(js_name = "getChainLockProof")]
+    pub fn get_chain_lock(&self) -> ChainAssetLockProofWASM {
+        self.clone().0.into()
+    }
+
+    #[wasm_bindgen(js_name = "toObject")]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let json_value = self.0.to_raw_object().with_js_error()?;
+
+        Ok(json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?)
+    }
+}

package/packages/asset_lock_proof/src/outpoint/mod.rs

@@ -0,0 +1,79 @@
+use dpp::dashcore::{OutPoint, Txid};
+use pshenmic_dpp_utils::IntoWasm;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "OutPointWASM")]
+#[derive(Clone)]
+pub struct OutPointWASM(OutPoint);
+
+impl From<OutPoint> for OutPointWASM {
+    fn from(outpoint: OutPoint) -> Self {
+        OutPointWASM(outpoint)
+    }
+}
+
+impl From<OutPointWASM> for OutPoint {
+    fn from(outpoint: OutPointWASM) -> Self {
+        outpoint.0
+    }
+}
+
+impl TryFrom<JsValue> for OutPointWASM {
+    type Error = JsValue;
+    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        let value = value.to_wasm::<OutPointWASM>("OutPointWASM")?;
+
+        Ok(value.clone())
+    }
+}
+
+#[wasm_bindgen]
+impl OutPointWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(txid_hex: String, vout: u32) -> Result<OutPointWASM, JsValue> {
+        let out_point = Txid::from_hex(&txid_hex).map_err(|err| JsValue::from(err.to_string()))?;
+
+        Ok(OutPointWASM(OutPoint {
+            txid: out_point,
+            vout,
+        }))
+    }
+
+    #[wasm_bindgen(js_name = "getVOUT")]
+    pub fn get_vout(&self) -> u32 {
+        self.0.vout
+    }
+
+    #[wasm_bindgen(js_name = "getTXID")]
+    pub fn get_tx_id(&self) -> String {
+        self.0.txid.to_hex()
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let slice: [u8; 36] = self.0.into();
+        slice.to_vec()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_buffer(js_buffer: Vec<u8>) -> OutPointWASM {
+        let mut buffer = [0u8; 36];
+        let bytes = js_buffer.as_slice();
+        let len = bytes.len();
+        buffer[..len].copy_from_slice(bytes);
+
+        OutPointWASM(OutPoint::from(buffer))
+    }
+}
+
+impl OutPointWASM {
+    pub fn vec_from_js_value(js_outpoints: &js_sys::Array) -> Result<Vec<OutPointWASM>, JsValue> {
+        let outpoints: Vec<OutPointWASM> = js_outpoints
+            .iter()
+            .map(|key| OutPointWASM::try_from(key))
+            .collect::<Result<Vec<OutPointWASM>, JsValue>>()?;
+
+        Ok(outpoints)
+    }
+}

package/packages/asset_lock_proof/src/tx_out/mod.rs

@@ -0,0 +1,80 @@
+use dpp::dashcore::{ScriptBuf, TxOut};
+use js_sys::Uint8Array;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "TxOutWASM")]
+#[derive(Clone)]
+pub struct TxOutWASM(TxOut);
+
+impl From<TxOut> for TxOutWASM {
+    fn from(value: TxOut) -> Self {
+        TxOutWASM(value)
+    }
+}
+
+impl From<TxOutWASM> for TxOut {
+    fn from(value: TxOutWASM) -> Self {
+        value.0
+    }
+}
+
+#[wasm_bindgen]
+impl TxOutWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(value: u64, script_pubkey: JsValue) -> Result<TxOutWASM, JsValue> {
+        let tx_out: Result<TxOut, JsValue> = match script_pubkey.is_array() {
+            true => Ok(TxOut {
+                value,
+                script_pubkey: ScriptBuf::from_bytes(Uint8Array::from(script_pubkey).to_vec()),
+            }),
+            false => match script_pubkey.is_string() {
+                true => Ok(TxOut {
+                    value,
+                    script_pubkey: ScriptBuf::from_hex(&script_pubkey.as_string().unwrap())
+                        .map_err(|err| JsValue::from(err.to_string()))?,
+                }),
+                false => Err(JsValue::from("Invalid script pubkey")),
+            },
+        };
+
+        Ok(TxOutWASM(tx_out?))
+    }
+
+    #[wasm_bindgen(getter = "value")]
+    pub fn get_value(&self) -> u64 {
+        self.0.value
+    }
+
+    #[wasm_bindgen(getter = "scriptPubKeyHex")]
+    pub fn get_script_pubkey_hex(&self) -> String {
+        self.0.script_pubkey.to_hex_string()
+    }
+
+    #[wasm_bindgen(getter = "scriptPubKeyBytes")]
+    pub fn get_script_pubkey_bytes(&self) -> Vec<u8> {
+        self.0.script_pubkey.to_bytes()
+    }
+
+    #[wasm_bindgen(setter = "value")]
+    pub fn set_value(&mut self, value: u64) {
+        self.0.value = value;
+    }
+
+    #[wasm_bindgen(setter = "scriptPubKeyHex")]
+    pub fn set_script_pubkey_hex(&mut self, script_pubkey_hex: String) -> Result<(), JsValue> {
+        self.0.script_pubkey = ScriptBuf::from_hex(&script_pubkey_hex)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = "scriptPubKeyBytes")]
+    pub fn set_script_pubkey_bytes(&mut self, script_pubkey_bytes: Vec<u8>) {
+        self.0.script_pubkey = ScriptBuf::from_bytes(script_pubkey_bytes);
+    }
+
+    #[wasm_bindgen(js_name = "getScriptPubKeyASM")]
+    pub fn get_script_pubkey_asm(&self) -> String {
+        self.0.script_pubkey.to_asm_string()
+    }
+}

package/packages/cbor_conversation/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2024"
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+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 = [
     "cbor",
 ]}

package/packages/core_script/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "pshenmic_dpp_core_script"
+edition = "2024"
+version.workspace = true
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+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-transition-signing"
+]}

package/packages/core_script/src/lib.rs

@@ -0,0 +1,69 @@
+use dpp::dashcore::opcodes;
+use dpp::identity::core_script::CoreScript;
+use dpp::platform_value::string_encoding::Encoding::Base64;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "CoreScriptWASM")]
+#[derive(Clone)]
+pub struct CoreScriptWASM(CoreScript);
+
+impl From<CoreScriptWASM> for CoreScript {
+    fn from(value: CoreScriptWASM) -> Self {
+        value.0
+    }
+}
+
+impl From<CoreScript> for CoreScriptWASM {
+    fn from(value: CoreScript) -> Self {
+        CoreScriptWASM(value)
+    }
+}
+
+#[wasm_bindgen]
+impl CoreScriptWASM {
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Self {
+        CoreScriptWASM(CoreScript::from_bytes(bytes))
+    }
+
+    #[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();
+        let len = bytes.len().min(32);
+        key_hash[..len].copy_from_slice(&bytes[..len]);
+
+        CoreScriptWASM(CoreScript::new_p2pkh(key_hash))
+    }
+
+    #[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();
+        let len = bytes.len().min(32);
+        script_hash[..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.push(opcodes::all::OP_EQUAL.to_u8());
+        Self::from_bytes(bytes)
+    }
+
+    #[wasm_bindgen(js_name = "toString")]
+    pub fn to_string(&self) -> String {
+        self.0.to_string(Base64)
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Vec<u8> {
+        self.0.to_bytes()
+    }
+
+    #[wasm_bindgen(js_name = "toASMString")]
+    pub fn to_asm_string(&self) -> String {
+        self.0.to_asm_string()
+    }
+}

package/packages/data_contract/Cargo.toml

@@ -7,9 +7,10 @@ edition = "2024"
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_identifier = { path = "../identifier" }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "data-contract-json-conversion",
 ]}

package/packages/data_contract/src/lib.rs

@@ -16,7 +16,8 @@ use dpp::serialization::{
 };
 use dpp::version::PlatformVersion;
 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;
@@ -41,7 +42,7 @@ impl From<DataContractWASM> for DataContract {
 impl DataContractWASM {
     #[wasm_bindgen(constructor)]
     pub fn from_js_values(
-        js_owner_id: JsValue,
+        js_owner_id: &JsValue,
         identity_nonce: IdentityNonce,
         js_schema: JsValue,
         js_definitions: Option<js_sys::Object>,
@@ -50,14 +51,14 @@ impl DataContractWASM {
     ) -> Result<DataContractWASM, JsValue> {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
 
-        let owner_id = identifier_from_js_value(&js_owner_id)?;
+        let owner_id: IdentifierWASM = js_owner_id.clone().try_into()?;
 
-        let owner_id_value = Value::from(owner_id.to_string(Base58));
+        let owner_id_value = Value::from(owner_id.get_base58());
 
         let schema: Value = serde_wasm_bindgen::from_value(js_schema)?;
 
         let platform_version: PlatformVersion = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1.into(),
+            true => PlatformVersionWASM::default().into(),
             false => PlatformVersionWASM::try_from(js_platform_version)?.into(),
         };
 
@@ -75,7 +76,8 @@ impl DataContractWASM {
 
         let definitions_value = Value::from(definitions);
 
-        let data_contract_id = DataContract::generate_data_contract_id_v0(owner_id, identity_nonce);
+        let data_contract_id =
+            DataContract::generate_data_contract_id_v0(owner_id.get_bytes(), identity_nonce);
 
         let data_contract_id_value = Value::from(data_contract_id.to_string(Base58));
 
@@ -130,7 +132,7 @@ impl DataContractWASM {
         js_platform_version: JsValue,
     ) -> Result<DataContractWASM, JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -150,7 +152,7 @@ impl DataContractWASM {
         js_platform_version: JsValue,
     ) -> Result<DataContractWASM, JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -167,7 +169,7 @@ impl DataContractWASM {
     #[wasm_bindgen(js_name = "toBytes")]
     pub fn to_bytes(&self, 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)?,
         };
 
@@ -181,7 +183,7 @@ impl DataContractWASM {
     #[wasm_bindgen(js_name = "toValue")]
     pub fn to_value(&self, js_platform_version: JsValue) -> Result<JsValue, JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -211,13 +213,13 @@ impl DataContractWASM {
     }
 
     #[wasm_bindgen(js_name = "getId")]
-    pub fn get_id(&self) -> Vec<u8> {
-        self.0.id().to_vec()
+    pub fn get_id(&self) -> IdentifierWASM {
+        self.0.id().into()
     }
 
     #[wasm_bindgen(js_name = "getOwnerId")]
-    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(js_name = "getConfig")]
@@ -229,17 +231,17 @@ impl DataContractWASM {
     }
 
     #[wasm_bindgen(js_name = "setId")]
-    pub fn set_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_id(data_contract_id))
+    pub fn set_id(&mut self, js_data_contract_id: &JsValue) -> Result<(), JsValue> {
+        self.0
+            .set_id(IdentifierWASM::try_from(js_data_contract_id)?.into());
+        Ok(())
     }
 
     #[wasm_bindgen(js_name = "setOwnerId")]
-    pub fn set_owner_id(&mut self, js_owner_id: JsValue) -> Result<(), JsValue> {
-        let owner_id = identifier_from_js_value(&js_owner_id)?;
-
-        Ok(self.0.set_owner_id(owner_id))
+    pub fn set_owner_id(&mut self, js_owner_id: &JsValue) -> Result<(), JsValue> {
+        self.0
+            .set_owner_id(IdentifierWASM::try_from(js_owner_id)?.into());
+        Ok(())
     }
 
     #[wasm_bindgen(js_name = "setVersion")]
@@ -254,7 +256,7 @@ impl DataContractWASM {
         js_platform_version: JsValue,
     ) -> Result<(), JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -277,7 +279,7 @@ impl DataContractWASM {
         js_platform_version: JsValue,
     ) -> Result<(), JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -303,7 +305,7 @@ impl DataContractWASM {
     #[wasm_bindgen(js_name = "toJson")]
     pub fn to_json(&self, js_platform_version: JsValue) -> Result<JsValue, JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -315,12 +317,14 @@ impl DataContractWASM {
 
     #[wasm_bindgen(js_name = "generateId")]
     pub fn generate_id(
-        js_owner_id: JsValue,
+        js_owner_id: &JsValue,
         identity_nonce: IdentityNonce,
-    ) -> Result<Vec<u8>, JsValue> {
-        let owner_id = identifier_from_js_value(&js_owner_id)?;
-
-        Ok(DataContract::generate_data_contract_id_v0(owner_id, identity_nonce).to_vec())
+    ) -> Result<IdentifierWASM, JsValue> {
+        Ok(DataContract::generate_data_contract_id_v0(
+            IdentifierWASM::try_from(js_owner_id)?.get_bytes(),
+            identity_nonce,
+        )
+        .into())
     }
 }
 

package/packages/data_contract_transitions/Cargo.toml

@@ -4,7 +4,7 @@ version.workspace = true
 edition = "2024"
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+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-transition-signing"
 ]}

package/packages/data_contract_transitions/src/create/mod.rs

@@ -32,7 +32,7 @@ impl DataContractCreateTransitionWASM {
         let rs_data_contract: DataContract = data_contract.clone().into();
 
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -96,7 +96,7 @@ impl DataContractCreateTransitionWASM {
         js_platform_version: JsValue,
     ) -> Result<(), JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -119,7 +119,7 @@ impl DataContractCreateTransitionWASM {
         full_validation: Option<bool>,
     ) -> Result<DataContractWASM, JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 

package/packages/data_contract_transitions/src/update/mod.rs

@@ -25,7 +25,7 @@ impl DataContractUpdateTransitionWASM {
         js_platform_version: JsValue,
     ) -> Result<DataContractUpdateTransitionWASM, JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -79,7 +79,7 @@ impl DataContractUpdateTransitionWASM {
         js_platform_version: JsValue,
     ) -> Result<(), JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 
@@ -102,7 +102,7 @@ impl DataContractUpdateTransitionWASM {
         js_platform_version: JsValue,
     ) -> Result<DataContractWASM, JsValue> {
         let platform_version = match js_platform_version.is_undefined() {
-            true => PlatformVersionWASM::PLATFORM_V1,
+            true => PlatformVersionWASM::default(),
             false => PlatformVersionWASM::try_from(js_platform_version)?,
         };
 

package/packages/document/Cargo.toml

@@ -7,8 +7,9 @@ edition = "2024"
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
 pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_identifier = { path = "../identifier" }
 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 = [