@dashevo/wasm-dpp 0.25.0-dev.15 → 0.25.0-dev.17

package/src/data_contract/data_contract.rs

@@ -4,20 +4,29 @@ use std::collections::BTreeMap;
 use std::convert::TryFrom;
 
 pub use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
 use wasm_bindgen::prelude::*;
 
-use dpp::data_contract::{CreatedDataContract, DataContract, SCHEMA_URI};
-use dpp::platform_value::string_encoding::Encoding;
-use dpp::platform_value::{Bytes32, Value};
-
-use dpp::serialization_traits::PlatformSerializable;
-use dpp::{platform_value, Convertible, ProtocolError};
+use dpp::data_contract::schema::DataContractSchemaMethodsV0;
+use dpp::data_contract::{DataContract, DocumentName, JsonValue};
+use dpp::platform_value::{platform_value, Bytes32, Value};
+
+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::created_data_contract::CreatedDataContract;
+use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
+use dpp::data_contract::serialized_version::DataContractInSerializationFormat;
+use dpp::serialization::{PlatformSerializable, PlatformSerializableWithPlatformVersion};
+use dpp::version::PlatformVersion;
+use dpp::{platform_value, ProtocolError};
 
 use crate::identifier::identifier_from_js_value;
 use crate::metadata::MetadataWasm;
-use crate::utils::{Inner, IntoWasm, WithJsError};
-use crate::{bail_js, with_js_error};
+use crate::utils::get_bool_from_options;
+use crate::utils::SKIP_VALIDATION_PROPERTY_NAME;
+use crate::utils::{Inner, IntoWasm, ToSerdeJSONExt, WithJsError};
+use crate::{bail_js, console_log, with_js_error};
 use crate::{buffer::Buffer, identifier::IdentifierWrapper};
 
 #[wasm_bindgen(js_name=DataContract)]
@@ -29,18 +38,18 @@ pub struct DataContractWasm {
 
 /// CreatedDataContract contains entropy and is used to create
 /// DataContractCreateTransition
-impl std::convert::From<CreatedDataContract> for DataContractWasm {
+impl From<CreatedDataContract> for DataContractWasm {
     fn from(v: CreatedDataContract) -> Self {
         DataContractWasm {
-            inner: v.data_contract,
-            entropy_used: Some(v.entropy_used.to_vec()),
+            inner: v.data_contract().clone(),
+            entropy_used: Some(v.entropy_used().to_vec()),
         }
     }
 }
 
 /// Regular DataContract does not contain entropy and is used
 /// in DataContractUpdateTransition
-impl std::convert::From<DataContract> for DataContractWasm {
+impl From<DataContract> for DataContractWasm {
     fn from(v: DataContract) -> Self {
         DataContractWasm {
             inner: v,
@@ -49,113 +58,88 @@ impl std::convert::From<DataContract> for DataContractWasm {
     }
 }
 
-impl std::convert::From<&DataContractWasm> for DataContract {
+impl From<&DataContractWasm> for DataContract {
     fn from(v: &DataContractWasm) -> Self {
         v.inner.clone()
     }
 }
 
-impl std::convert::TryFrom<&DataContractWasm> for CreatedDataContract {
+impl TryFrom<&DataContractWasm> for CreatedDataContract {
     type Error = ProtocolError;
     fn try_from(v: &DataContractWasm) -> Result<Self, Self::Error> {
-        Ok(Self {
-            data_contract: v.to_owned().into(),
-            entropy_used: if let Some(entropy_used) = &v.entropy_used {
-                Bytes32::from_vec(entropy_used.to_owned())?
-            } else {
-                Bytes32::default()
-            },
-        })
+        let entropy = if let Some(entropy_used) = &v.entropy_used {
+            Bytes32::from_vec(entropy_used.to_owned())?
+        } else {
+            Bytes32::default()
+        };
+
+        let platform_version = PlatformVersion::first();
+
+        CreatedDataContract::from_contract_and_entropy(
+            v.to_owned().into(),
+            entropy,
+            platform_version,
+        )
     }
 }
 
-impl std::convert::Into<DataContract> for DataContractWasm {
+impl Into<DataContract> for DataContractWasm {
     fn into(self) -> DataContract {
         self.inner
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct DataContractParameters {
-    #[serde(
-        rename = "$schema",
-        skip_serializing_if = "serde_json::Value::is_null",
-        default
-    )]
-    schema: serde_json::Value,
-    #[serde(rename = "$id", skip_serializing_if = "Option::is_none")]
-    id: Option<Vec<u8>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    owner_id: Option<Vec<u8>>,
-    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
-    documents: serde_json::Value,
-    #[serde(
-        skip_serializing_if = "serde_json::Value::is_null",
-        default,
-        rename = "$defs"
-    )]
-    defs: serde_json::Value,
-    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
-    protocol_version: serde_json::Value,
-    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
-    version: serde_json::Value,
-
-    #[serde(flatten)]
-    _extras: serde_json::Value, // Captures excess fields to trigger validation failure later.
-}
-
-pub fn js_value_to_data_contract_value(object: JsValue) -> Result<Value, JsValue> {
-    let parameters: DataContractParameters =
-        with_js_error!(serde_wasm_bindgen::from_value(object))?;
-
-    platform_value::to_value(parameters).map_err(|e| e.to_string().into())
-}
-
 #[wasm_bindgen(js_class=DataContract)]
 impl DataContractWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_parameters: JsValue) -> Result<DataContractWasm, JsValue> {
-        let parameters: DataContractParameters =
-            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+    pub fn new(
+        raw_parameters: JsValue,
+        options: Option<js_sys::Object>,
+    ) -> Result<DataContractWasm, JsValue> {
+        let skip_validation = if let Some(opts) = options {
+            get_bool_from_options(opts.into(), SKIP_VALIDATION_PROPERTY_NAME, false)?
+        } else {
+            false
+        };
+
+        let platform_version = PlatformVersion::first();
 
-        DataContract::from_raw_object(
-            platform_value::to_value(parameters).expect("Implements Serialize"),
+        DataContract::from_value(
+            raw_parameters.with_serde_to_platform_value()?,
+            !skip_validation,
+            platform_version,
         )
         .with_js_error()
         .map(Into::into)
     }
 
-    #[wasm_bindgen(js_name=getProtocolVersion)]
-    pub fn get_protocol_version(&self) -> u32 {
-        self.inner.protocol_version
-    }
-
     #[wasm_bindgen(js_name=getId)]
-    pub fn get_id(&self) -> IdentifierWrapper {
-        self.inner.id.into()
+    pub fn id(&self) -> IdentifierWrapper {
+        self.inner.id().into()
     }
 
     #[wasm_bindgen(js_name=setId)]
     pub fn set_id(&mut self, id: &JsValue) -> Result<(), JsValue> {
         let id = identifier_from_js_value(id)?;
-        self.inner.id = id;
+
+        self.inner.set_id(id);
+
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getOwnerId)]
-    pub fn get_owner_id(&self) -> IdentifierWrapper {
-        self.inner.owner_id.into()
+    pub fn owner_id(&self) -> IdentifierWrapper {
+        self.inner.owner_id().into()
     }
 
     #[wasm_bindgen(js_name=getVersion)]
-    pub fn get_version(&self) -> u32 {
-        self.inner.version
+    pub fn version(&self) -> u32 {
+        self.inner.version()
     }
 
     #[wasm_bindgen(js_name=setVersion)]
     pub fn set_version(&mut self, v: u32) {
-        self.inner.version = v;
+        self.inner.set_version(v);
     }
 
     #[wasm_bindgen(js_name=incrementVersion)]
@@ -163,106 +147,161 @@ impl DataContractWasm {
         self.inner.increment_version()
     }
 
-    #[wasm_bindgen(js_name=getJsonSchemaId)]
-    pub fn get_json_schema_id(&self) -> String {
-        self.inner.id.to_string(Encoding::Base58)
-    }
+    #[wasm_bindgen(js_name=getBinaryProperties)]
+    pub fn get_binary_properties(&self, doc_type: &str) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
 
-    #[wasm_bindgen(js_name=setJsonMetaSchema)]
-    pub fn set_json_meta_schema(&mut self, schema: String) {
-        self.inner.schema = schema;
-    }
+        let document_type = self
+            .inner
+            .document_type_for_name(doc_type)
+            .with_js_error()?;
+
+        let binary_paths_o = document_type.binary_paths();
+
+        let mut binary_paths = BTreeMap::new();
 
-    #[wasm_bindgen(js_name=getJsonMetaSchema)]
-    pub fn get_json_meta_schema(&self) -> String {
-        self.inner.schema.clone()
+        document_type.binary_paths().iter().for_each(
+            (|path| {
+                binary_paths.insert(path.to_owned(), platform_value!({}));
+            }),
+        );
+
+        document_type.identifier_paths().iter().for_each(
+            (|path| {
+                binary_paths.insert(
+                    path.to_owned(),
+                    platform_value!({
+                        "contentMediaType": "application/x.dash.dpp.identifier"
+                    }),
+                );
+            }),
+        );
+
+        with_js_error!(binary_paths.serialize(&serializer))
     }
-    #[wasm_bindgen(js_name=setDocuments)]
-    pub fn set_documents(&mut self, documents: JsValue) -> Result<(), JsValue> {
-        let json_value: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(documents))?;
 
-        let mut docs: BTreeMap<String, JsonValue> = BTreeMap::new();
-        if let JsonValue::Object(o) = json_value {
-            for (k, v) in o.into_iter() {
-                if !v.is_object() {
-                    bail_js!("is not an object")
-                }
-                docs.insert(k, v);
-            }
-            self.inner.documents = docs;
+    #[wasm_bindgen(js_name=setDocumentSchemas)]
+    pub fn set_document_schemas(
+        &mut self,
+        schemas: JsValue,
+        options: Option<js_sys::Object>,
+    ) -> Result<(), JsValue> {
+        let (skip_validation, defs) = if let Some(opts) = options {
+            let opts_value = opts.with_serde_to_platform_value()?;
+
+            (
+                get_bool_from_options(opts.into(), SKIP_VALIDATION_PROPERTY_NAME, false)?,
+                opts_value
+                    .get_optional_value("defs")
+                    .map_err(JsError::from)?
+                    .map(|defs| defs.clone().into_btree_string_map())
+                    .transpose()
+                    .map_err(JsError::from)?,
+            )
         } else {
-            bail_js!("the parameter 'documents' is not an JS object")
-        }
-        Ok(())
-    }
+            (false, None)
+        };
 
-    #[wasm_bindgen(js_name=getDocuments)]
-    pub fn get_documents(&self) -> Result<JsValue, JsValue> {
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(self.inner.documents.serialize(&serializer))
-    }
+        let document_schemas: Value = schemas.with_serde_to_platform_value()?;
+        let document_schemas_map = document_schemas
+            .into_btree_string_map()
+            .map_err(JsError::from)?;
 
-    #[wasm_bindgen(js_name=isDocumentDefined)]
-    pub fn is_document_defined(&self, doc_type: String) -> bool {
-        self.inner.is_document_defined(&doc_type)
+        let platform_version = PlatformVersion::first();
+
+        self.inner
+            .set_document_schemas(
+                document_schemas_map,
+                defs,
+                !skip_validation,
+                &platform_version,
+            )
+            .with_js_error()
     }
 
     #[wasm_bindgen(js_name=setDocumentSchema)]
     pub fn set_document_schema(
         &mut self,
-        doc_type: String,
+        name: &str,
         schema: JsValue,
+        options: Option<js_sys::Object>,
     ) -> Result<(), JsValue> {
-        let json_schema: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(schema))?;
+        let (skip_validation) = if let Some(options) = options {
+            get_bool_from_options(options.into(), SKIP_VALIDATION_PROPERTY_NAME, false)?
+        } else {
+            false
+        };
+
+        let schema_value: Value = schema.with_serde_to_platform_value()?;
+
+        let platform_version = PlatformVersion::first();
+
         self.inner
-            .set_document_schema(doc_type, json_schema)
-            .with_js_error()?;
-        Ok(())
+            .set_document_schema(name, schema_value, !skip_validation, &platform_version)
+            .with_js_error()
     }
 
     #[wasm_bindgen(js_name=getDocumentSchema)]
-    pub fn get_document_schema(&mut self, doc_type: &str) -> Result<JsValue, JsValue> {
-        let doc_schema = self.inner.get_document_schema(doc_type).with_js_error()?;
+    pub fn document_schema(&mut self, name: &str) -> Result<JsValue, JsValue> {
+        let document_type = self.inner.document_type_for_name(name).with_js_error()?;
+
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(doc_schema.serialize(&serializer))
-    }
-
-    #[wasm_bindgen(js_name=getDocumentSchemaRef)]
-    pub fn get_document_schema_ref(&self, doc_type: &str) -> Result<JsValue, JsValue> {
-        with_js_error!(serde_wasm_bindgen::to_value(
-            &self
-                .inner
-                .get_document_schema_ref(doc_type)
-                .with_js_error()?
-        ))
-    }
-
-    #[wasm_bindgen(js_name=setDefinitions)]
-    pub fn set_definitions(&mut self, definitions: JsValue) -> Result<(), JsValue> {
-        let json_value: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(definitions))?;
-        let mut definitions: BTreeMap<String, JsonValue> = BTreeMap::new();
-        if let JsonValue::Object(o) = json_value {
-            for (k, v) in o.into_iter() {
-                // v must be a Object
-                if !v.is_object() {
-                    bail_js!("{:?} is not an object", v);
-                }
-                definitions.insert(k, v);
-            }
-            if definitions.is_empty() {
-                bail_js!("`definitions` cannot be empty");
-            }
-            self.inner.defs = Some(definitions);
+
+        document_type
+            .schema()
+            .serialize(&serializer)
+            .map_err(JsError::from)
+            .map_err(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=getDocumentSchemas)]
+    pub fn document_schemas(&self) -> JsValue {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        self.inner
+            .document_schemas()
+            .serialize(&serializer)
+            .expect("document schemas defs to js value")
+    }
+
+    #[wasm_bindgen(js_name=getSchemaDefs)]
+    pub fn schema_defs(&self) -> JsValue {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        self.inner
+            .schema_defs()
+            .serialize(&serializer)
+            .expect("document schemas defs to js value")
+    }
+
+    #[wasm_bindgen(js_name=setSchemaDefs)]
+    pub fn set_schema_defs(
+        &mut self,
+        defs: Option<js_sys::Object>,
+        options: Option<js_sys::Object>,
+    ) -> Result<(), JsValue> {
+        let (skip_validation) = if let Some(options) = options {
+            get_bool_from_options(options.into(), SKIP_VALIDATION_PROPERTY_NAME, false)?
         } else {
-            bail_js!("the parameter 'definitions' is not an JS object");
-        }
+            false
+        };
+
+        let platform_version = PlatformVersion::first();
+
+        let maybe_schema_defs = defs
+            .map(|js_value| serde_wasm_bindgen::from_value(js_value.into()))
+            .transpose()?;
+
+        self.inner
+            .set_schema_defs(maybe_schema_defs, !skip_validation, platform_version)
+            .with_js_error()?;
+
         Ok(())
     }
 
-    #[wasm_bindgen(js_name=getDefinitions)]
-    pub fn get_definitions(&self) -> Result<JsValue, JsValue> {
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(self.inner.defs.serialize(&serializer))
+    #[wasm_bindgen(js_name=hasDocumentType)]
+    pub fn has_document_type(&self, doc_type: String) -> bool {
+        self.inner.has_document_type_for_name(&doc_type)
     }
 
     #[wasm_bindgen(js_name=setEntropy)]
@@ -272,97 +311,133 @@ impl DataContractWasm {
     }
 
     #[wasm_bindgen(js_name=getEntropy)]
-    pub fn get_entropy(&mut self) -> JsValue {
+    pub fn entropy(&mut self) -> JsValue {
         self.entropy_used
             .as_ref()
             .map(|e| Buffer::from_bytes(e.as_slice()).into())
             .unwrap_or(JsValue::undefined())
     }
 
-    #[wasm_bindgen(js_name=getBinaryProperties)]
-    pub fn get_binary_properties(&self, doc_type: &str) -> Result<JsValue, JsValue> {
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(self
-            .inner
-            .get_binary_properties(doc_type)
-            .with_js_error()?
-            .serialize(&serializer))
-    }
-
     #[wasm_bindgen(js_name=getMetadata)]
-    pub fn get_metadata(&self) -> Option<MetadataWasm> {
-        self.inner.metadata.clone().map(Into::into)
+    pub fn metadata(&self) -> Option<MetadataWasm> {
+        self.inner.metadata().cloned().map(Into::into)
     }
 
     #[wasm_bindgen(js_name=setMetadata)]
     pub fn set_metadata(&mut self, metadata: JsValue) -> Result<(), JsValue> {
-        self.inner.metadata = if !metadata.is_falsy() {
+        let metadata = if !metadata.is_falsy() {
             let metadata = metadata.to_wasm::<MetadataWasm>("Metadata")?;
             Some(metadata.to_owned().into())
         } else {
             None
         };
 
+        self.inner.set_metadata(metadata);
+
         Ok(())
     }
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self) -> Result<JsValue, JsValue> {
-        let value = self.inner.to_cleaned_object().with_js_error()?;
+        let platform_version = PlatformVersion::first();
+
+        let value = self.inner.to_value(platform_version).with_js_error()?;
+
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
         let object = with_js_error!(value.serialize(&serializer))?;
 
         js_sys::Reflect::set(
             &object,
-            &Into::<JsValue>::into("$id".to_owned()),
-            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.inner.id.to_vec())),
+            &Into::<JsValue>::into("id".to_owned()),
+            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.inner.id().to_vec())),
         )
         .expect("target is an object");
         js_sys::Reflect::set(
             &object,
             &Into::<JsValue>::into("ownerId".to_owned()),
-            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.inner.owner_id.to_vec())),
+            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.inner.owner_id().to_vec())),
         )
         .expect("target is an object");
         Ok(object)
     }
 
+    #[wasm_bindgen(js_name=getConfig)]
+    pub fn config(&self) -> Result<JsValue, JsValue> {
+        Ok(serde_wasm_bindgen::to_value(&self.inner.config())?)
+    }
+
+    #[wasm_bindgen(js_name=setConfig)]
+    pub fn set_config(&mut self, config: JsValue) -> Result<(), JsValue> {
+        let value = config.with_serde_to_platform_value()?;
+
+        let platform_version = &PlatformVersion::first();
+
+        let data_contract_config =
+            DataContractConfig::from_value(value, platform_version).with_js_error()?;
+
+        self.inner.set_config(data_contract_config);
+
+        Ok(())
+    }
+
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let json = self.inner.to_json().with_js_error()?;
+        let platform_version = PlatformVersion::first();
+
+        let json = self.inner.to_json(platform_version).with_js_error()?;
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         with_js_error!(json.serialize(&serializer))
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes = PlatformSerializable::serialize(&self.inner).with_js_error()?;
+        let platform_version = PlatformVersion::first();
+
+        let bytes = self
+            .inner
+            .serialize_to_bytes_with_platform_version(platform_version)
+            .with_js_error()?;
+
         Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=hash)]
     pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
-        self.inner.hash().with_js_error()
-    }
+        let platform_version = PlatformVersion::first();
 
-    #[wasm_bindgen(js_name=from)]
-    pub fn from_js_value(v: JsValue) -> Result<DataContractWasm, JsValue> {
-        let json_contract: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(v))?;
-        Ok(DataContract::try_from(json_contract)
-            .with_js_error()?
-            .into())
+        self.inner.hash(platform_version).with_js_error()
     }
 
-    #[wasm_bindgen(js_name=fromBuffer)]
-    pub fn from_buffer(b: &[u8]) -> Result<DataContractWasm, JsValue> {
-        let data_contract = DataContract::from_cbor(b).with_js_error()?;
-        Ok(data_contract.into())
-    }
+    // #[wasm_bindgen(js_name=from)]
+    // pub fn from_js_value(v: JsValue) -> Result<DataContractWasm, JsValue> {
+    //     let json_contract: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(v))?;
+    //     Ok(DataContract::try_from(json_contract)
+    //         .with_js_error()?
+    //         .into())
+    // }
+
+    // #[wasm_bindgen(js_name=fromBuffer)]
+    // pub fn from_buffer(b: &[u8]) -> Result<DataContractWasm, JsValue> {
+    //     let data_contract = DataContract::from_cbor(b).with_js_error()?;
+    //     Ok(data_contract.into())
+    // }
 
     #[wasm_bindgen(js_name=clone)]
     pub fn deep_clone(&self) -> Self {
         self.clone()
     }
+
+    pub(crate) fn try_from_serialization_format(
+        value: DataContractInSerializationFormat,
+        validate: bool,
+    ) -> Result<Self, JsValue> {
+        let platform_version = PlatformVersion::first();
+
+        DataContract::try_from_platform_versioned(value, validate, platform_version)
+            .with_js_error()
+            .map(Into::into)
+    }
 }
 
 impl Inner for DataContractWasm {
@@ -386,14 +461,3 @@ impl DataContractWasm {
         &self.inner
     }
 }
-
-#[wasm_bindgen(js_name=DataContractDefaults)]
-pub struct DataContractDefaults;
-
-#[wasm_bindgen(js_class=DataContractDefaults)]
-impl DataContractDefaults {
-    #[wasm_bindgen(getter = SCHEMA)]
-    pub fn get_default_schema() -> String {
-        SCHEMA_URI.to_string()
-    }
-}