pshenmic-dpp 1.0.4 → 1.0.6

package/packages/data_contract/src/lib.rs

@@ -1,18 +1,24 @@
 use dpp::dashcore::hashes::serde::Serialize;
 use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
+use dpp::data_contract::config::DataContractConfig;
 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::platform_value::{Value, ValueMap};
 use dpp::prelude::IdentityNonce;
 use dpp::serialization::{
     PlatformDeserializableWithPotentialValidationFromVersionedStructure,
     PlatformSerializableWithPlatformVersion,
 };
+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;
 
@@ -35,11 +41,101 @@ impl From<DataContractWASM> for DataContract {
 #[wasm_bindgen]
 impl DataContractWASM {
     #[wasm_bindgen(constructor)]
-    pub fn new(
+    pub fn from_js_values(
+        js_owner_id: &JsValue,
+        identity_nonce: IdentityNonce,
+        js_schema: JsValue,
+        js_definitions: Option<js_sys::Object>,
+        full_validation: bool,
+        js_platform_version: JsValue,
+    ) -> Result<DataContractWASM, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        let owner_id: IdentifierWASM = js_owner_id.clone().try_into()?;
+
+        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::default().into(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?.into(),
+        };
+
+        let data_contract_structure_version_value = Value::from(
+            platform_version
+                .dpp
+                .contract_versions
+                .contract_structure_version
+                .to_string(),
+        );
+
+        let definitions = js_definitions
+            .map(|definitions| serde_wasm_bindgen::from_value(definitions.into()))
+            .transpose()?;
+
+        let definitions_value = Value::from(definitions);
+
+        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));
+
+        let config =
+            DataContractConfig::default_for_version(&platform_version.clone()).with_js_error()?;
+
+        let config_value = config
+            .serialize(&serializer)
+            .map_err(JsValue::from)?
+            .with_serde_to_platform_value_map()?;
+
+        let mut contract_value = Value::Map(ValueMap::new());
+
+        contract_value
+            .set_value("$format_version", data_contract_structure_version_value)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("id", data_contract_id_value)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("config", Value::from(config_value))
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("version", Value::from(1u16))
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("ownerId", owner_id_value)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("schemaDefs", definitions_value)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        contract_value
+            .set_value("documentSchemas", schema)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        Ok(DataContractWASM(
+            DataContract::from_value(contract_value, full_validation, &platform_version)
+                .with_js_error()?,
+        ))
+    }
+
+    #[wasm_bindgen(js_name = "fromValue")]
+    pub fn from_value(
         js_value: JsValue,
         full_validation: bool,
-        platform_version: PlatformVersionWASM,
+        js_platform_version: JsValue,
     ) -> Result<DataContractWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let value = js_value.with_serde_to_platform_value()?;
 
         let v0_contract =
@@ -53,8 +149,13 @@ impl DataContractWASM {
     pub fn from_bytes(
         bytes: Vec<u8>,
         full_validation: bool,
-        platform_version: PlatformVersionWASM,
+        js_platform_version: JsValue,
     ) -> Result<DataContractWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let rs_data_contract = DataContract::versioned_deserialize(
             &bytes.as_slice(),
             full_validation,
@@ -66,7 +167,12 @@ impl DataContractWASM {
     }
 
     #[wasm_bindgen(js_name = "toBytes")]
-    pub fn to_bytes(&self, platform_version: PlatformVersionWASM) -> Result<Vec<u8>, JsValue> {
+    pub fn to_bytes(&self, js_platform_version: JsValue) -> Result<Vec<u8>, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let rs_data_contract: DataContract = self.0.clone();
 
         rs_data_contract
@@ -75,7 +181,12 @@ impl DataContractWASM {
     }
 
     #[wasm_bindgen(js_name = "toValue")]
-    pub fn to_value(&self, platform_version: PlatformVersionWASM) -> Result<JsValue, JsValue> {
+    pub fn to_value(&self, js_platform_version: JsValue) -> Result<JsValue, 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();
 
         self.0
@@ -86,7 +197,7 @@ impl DataContractWASM {
             .map_err(JsValue::from)
     }
 
-    #[wasm_bindgen(js_name = "getSchemas")]
+    #[wasm_bindgen(js_name = "getSchema")]
     pub fn get_schemas(&self) -> Result<JsValue, JsValue> {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
 
@@ -96,19 +207,19 @@ impl DataContractWASM {
             .map_err(JsValue::from)
     }
 
-    #[wasm_bindgen(js_name = "getDataContractVersion")]
-    pub fn get_data_contract_version(&self) -> u32 {
+    #[wasm_bindgen(js_name = "getVersion")]
+    pub fn get_version(&self) -> u32 {
         self.0.version()
     }
 
     #[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")]
@@ -119,36 +230,101 @@ impl DataContractWASM {
             .map_err(JsValue::from)
     }
 
-    #[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()?;
+    #[wasm_bindgen(js_name = "setId")]
+    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(())
+    }
 
-        json.serialize(&serde_wasm_bindgen::Serializer::json_compatible())
-            .map_err(JsValue::from)
+    #[wasm_bindgen(js_name = "setOwnerId")]
+    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 = "generateId")]
-    pub fn generate_id(
-        js_owner_id: JsValue,
-        identity_nonce: IdentityNonce,
-    ) -> Result<Vec<u8>, JsValue> {
-        let owner_id = identifier_from_js_value(&js_owner_id)?;
+    #[wasm_bindgen(js_name = "setVersion")]
+    pub fn set_version(&mut self, version: u32) {
+        self.0.set_version(version)
+    }
+
+    #[wasm_bindgen(js_name = "setConfig")]
+    pub fn set_config(
+        &mut self,
+        js_config: JsValue,
+        js_platform_version: JsValue,
+    ) -> Result<(), JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let config_value: Value = serde_wasm_bindgen::from_value(js_config)?;
 
-        Ok(DataContract::generate_data_contract_id_v0(owner_id, identity_nonce).to_vec())
+        let config = DataContractConfig::from_value(config_value, &platform_version.into())
+            .with_js_error()?;
+
+        self.0.set_config(config);
+
+        Ok(())
     }
 
-    #[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)?;
+    #[wasm_bindgen(js_name = "setSchema")]
+    pub fn set_schemas(
+        &mut self,
+        js_schema: JsValue,
+        js_definitions: Option<js_sys::Object>,
+        full_validation: bool,
+        js_platform_version: JsValue,
+    ) -> Result<(), JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
 
-        Ok(self.0.set_id(data_contract_id))
+        let schema = js_schema.with_serde_to_platform_value_map()?;
+
+        let definitions: Option<BTreeMap<String, Value>> = js_definitions
+            .map(|definitions| serde_wasm_bindgen::from_value(definitions.into()))
+            .transpose()?;
+
+        self.0
+            .set_document_schemas(
+                schema,
+                definitions,
+                full_validation,
+                &mut Vec::new(),
+                &platform_version.into(),
+            )
+            .with_js_error()?;
+
+        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)?;
+    #[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::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let json = self.0.to_json(&platform_version.into()).with_js_error()?;
 
-        Ok(self.0.set_owner_id(owner_id))
+        json.serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .map_err(JsValue::from)
+    }
+
+    #[wasm_bindgen(js_name = "generateId")]
+    pub fn generate_id(
+        js_owner_id: &JsValue,
+        identity_nonce: IdentityNonce,
+    ) -> 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

@@ -1,10 +1,10 @@
 [package]
 name = "pshenmic_dpp_data_contract_transitions"
-version = "0.1.0"
+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

@@ -27,18 +27,19 @@ impl DataContractCreateTransitionWASM {
     pub fn new(
         data_contract: &DataContractWASM,
         identity_nonce: IdentityNonce,
-        platform_version: Option<PlatformVersionWASM>,
+        js_platform_version: JsValue,
     ) -> Result<DataContractCreateTransitionWASM, JsValue> {
         let rs_data_contract: DataContract = data_contract.clone().into();
 
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let rs_data_contract_in_serialized: Result<
             DataContractInSerializationFormat,
             ProtocolError,
-        > = rs_data_contract.try_into_platform_versioned(
-            &platform_version
-                .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
-                .into(),
-        );
+        > = rs_data_contract.try_into_platform_versioned(&platform_version.into());
 
         let rs_data_contract_create_transition_v0: DataContractCreateTransitionV0 =
             DataContractCreateTransitionV0 {
@@ -91,15 +92,18 @@ impl DataContractCreateTransitionWASM {
     #[wasm_bindgen(js_name = "setDataContract")]
     pub fn set_data_contract(
         &mut self,
-        data_contract: DataContractWASM,
-        platform_version_wasm: Option<PlatformVersionWASM>,
+        data_contract: &DataContractWASM,
+        js_platform_version: JsValue,
     ) -> Result<(), JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let data_contract_serialization_format =
             DataContractInSerializationFormat::try_from_platform_versioned(
-                DataContract::from(data_contract),
-                &platform_version_wasm
-                    .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
-                    .into(),
+                DataContract::from(data_contract.clone()),
+                &platform_version.into(),
             )
             .with_js_error()?;
 
@@ -111,9 +115,14 @@ impl DataContractCreateTransitionWASM {
     #[wasm_bindgen(js_name = "getDataContract")]
     pub fn get_data_contract(
         &self,
-        platform_version_wasm: Option<PlatformVersionWASM>,
+        js_platform_version: JsValue,
         full_validation: Option<bool>,
     ) -> Result<DataContractWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let rs_data_contract_serialization_format = self.0.data_contract();
 
         let mut validation_operations: Vec<ProtocolValidationOperation> = Vec::new();
@@ -122,9 +131,7 @@ impl DataContractCreateTransitionWASM {
             rs_data_contract_serialization_format.clone(),
             full_validation.unwrap_or(false),
             &mut validation_operations,
-            &platform_version_wasm
-                .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
-                .into(),
+            &platform_version.into(),
         )
         .with_js_error()?;
 

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

@@ -22,14 +22,17 @@ impl DataContractUpdateTransitionWASM {
     pub fn new(
         data_contract: &DataContractWASM,
         identity_nonce: IdentityNonce,
-        platform_version: Option<PlatformVersionWASM>,
+        js_platform_version: JsValue,
     ) -> Result<DataContractUpdateTransitionWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let rs_data_contract_update_transition =
             DataContractUpdateTransition::try_from_platform_versioned(
                 (DataContract::from(data_contract.clone()), identity_nonce),
-                &platform_version
-                    .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
-                    .into(),
+                &platform_version.into(),
             )
             .with_js_error()?;
 
@@ -73,14 +76,17 @@ impl DataContractUpdateTransitionWASM {
     pub fn set_data_contract(
         &mut self,
         data_contract: &DataContractWASM,
-        platform_version_wasm: Option<PlatformVersionWASM>,
+        js_platform_version: JsValue,
     ) -> Result<(), JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let data_contract_serialization_format =
             DataContractInSerializationFormat::try_from_platform_versioned(
                 DataContract::from(data_contract.clone()),
-                &platform_version_wasm
-                    .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
-                    .into(),
+                &platform_version.into(),
             )
             .with_js_error()?;
 
@@ -93,8 +99,13 @@ impl DataContractUpdateTransitionWASM {
     pub fn get_data_contract(
         &self,
         full_validation: Option<bool>,
-        platform_version_wasm: Option<PlatformVersionWASM>,
+        js_platform_version: JsValue,
     ) -> Result<DataContractWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::default(),
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
         let data_contract_serialization_format = self.0.data_contract();
 
         let mut validation_operations: Vec<ProtocolValidationOperation> = Vec::new();
@@ -103,9 +114,7 @@ impl DataContractUpdateTransitionWASM {
             data_contract_serialization_format.clone(),
             full_validation.unwrap_or(false),
             &mut validation_operations,
-            &platform_version_wasm
-                .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
-                .into(),
+            &platform_version.into(),
         )
         .with_js_error()?;
 

package/packages/document/Cargo.toml

@@ -1,14 +1,15 @@
 [package]
 name = "pshenmic_dpp_document"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
 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 = [

package/packages/document/src/lib.rs

@@ -1,20 +1,21 @@
-mod methods;
+pub mod methods;
 
 use dpp::document::{Document, DocumentV0, DocumentV0Getters};
 use dpp::identifier::Identifier;
 use dpp::identity::TimestampMillis;
 use dpp::platform_value::Value;
 use dpp::prelude::{BlockHeight, CoreBlockHeight, Revision};
+use pshenmic_dpp_identifier::IdentifierWASM;
 use std::collections::BTreeMap;
 use wasm_bindgen::prelude::wasm_bindgen;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Clone)]
 #[wasm_bindgen(js_name = DocumentWASM)]
 pub struct DocumentWASM {
-    id: Identifier,
-    owner_id: Identifier,
+    id: IdentifierWASM,
+    owner_id: IdentifierWASM,
     revision: Option<Revision>,
-    data_contract_id: Identifier,
+    data_contract_id: IdentifierWASM,
     document_type_name: String,
     properties: BTreeMap<String, Value>,
     created_at: Option<TimestampMillis>,
@@ -32,8 +33,8 @@ pub struct DocumentWASM {
 impl From<DocumentWASM> for Document {
     fn from(wasm_doc: DocumentWASM) -> Self {
         Document::V0(DocumentV0 {
-            id: wasm_doc.id,
-            owner_id: wasm_doc.owner_id,
+            id: wasm_doc.id.into(),
+            owner_id: wasm_doc.owner_id.into(),
             properties: wasm_doc.properties,
             revision: wasm_doc.revision,
             created_at: wasm_doc.created_at,
@@ -52,10 +53,10 @@ impl From<DocumentWASM> for Document {
 impl From<Document> for DocumentWASM {
     fn from(doc: Document) -> Self {
         DocumentWASM {
-            id: doc.id(),
-            owner_id: doc.owner_id(),
+            id: doc.id().into(),
+            owner_id: doc.owner_id().into(),
             revision: doc.revision(),
-            data_contract_id: Default::default(),
+            data_contract_id: Identifier::default().into(),
             document_type_name: "".to_string(),
             properties: doc.properties().clone(),
             created_at: doc.created_at(),
@@ -80,10 +81,10 @@ impl DocumentWASM {
         entropy: Option<[u8; 32]>,
     ) -> Self {
         DocumentWASM {
-            id: document.id(),
-            owner_id: document.owner_id(),
+            id: document.id().into(),
+            owner_id: document.owner_id().into(),
             revision: document.revision(),
-            data_contract_id,
+            data_contract_id: data_contract_id.into(),
             document_type_name,
             properties: document.properties().clone(),
             created_at: document.created_at(),