pshenmic-dpp 1.0.3 → 1.0.5

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

@@ -0,0 +1,144 @@
+use dpp::data_contract::serialized_version::DataContractInSerializationFormat;
+use dpp::prelude::{DataContract, IdentityNonce};
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::state_transition::StateTransition;
+use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition;
+use dpp::state_transition::data_contract_update_transition::accessors::DataContractUpdateTransitionAccessorsV0;
+use dpp::validation::operations::ProtocolValidationOperation;
+use dpp::version::{FeatureVersion, ProtocolVersion, TryFromPlatformVersioned};
+use pshenmic_dpp_data_contract::DataContractWASM;
+use pshenmic_dpp_enums::platform::PlatformVersionWASM;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::WithJsError;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "DataContractUpdateTransitionWASM")]
+pub struct DataContractUpdateTransitionWASM(DataContractUpdateTransition);
+
+#[wasm_bindgen]
+impl DataContractUpdateTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        data_contract: &DataContractWASM,
+        identity_nonce: IdentityNonce,
+        js_platform_version: JsValue,
+    ) -> Result<DataContractUpdateTransitionWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            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.into(),
+            )
+            .with_js_error()?;
+
+        Ok(DataContractUpdateTransitionWASM(
+            rs_data_contract_update_transition,
+        ))
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<DataContractUpdateTransitionWASM, JsValue> {
+        let rs_data_contract_update_transition: DataContractUpdateTransition =
+            DataContractUpdateTransition::deserialize_from_bytes(bytes.as_slice())
+                .with_js_error()?;
+
+        Ok(DataContractUpdateTransitionWASM(
+            rs_data_contract_update_transition,
+        ))
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "getFeatureVersion")]
+    pub fn get_feature_version(&self) -> FeatureVersion {
+        self.0.feature_version()
+    }
+
+    #[wasm_bindgen(js_name = "verifyProtocolVersion")]
+    pub fn verify_protocol_version(
+        &self,
+        protocol_version: ProtocolVersion,
+    ) -> Result<bool, JsValue> {
+        self.0
+            .verify_protocol_version(protocol_version)
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "setDataContract")]
+    pub fn set_data_contract(
+        &mut self,
+        data_contract: &DataContractWASM,
+        js_platform_version: JsValue,
+    ) -> Result<(), JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let data_contract_serialization_format =
+            DataContractInSerializationFormat::try_from_platform_versioned(
+                DataContract::from(data_contract.clone()),
+                &platform_version.into(),
+            )
+            .with_js_error()?;
+
+        self.0.set_data_contract(data_contract_serialization_format);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = "getDataContract")]
+    pub fn get_data_contract(
+        &self,
+        full_validation: Option<bool>,
+        js_platform_version: JsValue,
+    ) -> Result<DataContractWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let data_contract_serialization_format = self.0.data_contract();
+
+        let mut validation_operations: Vec<ProtocolValidationOperation> = Vec::new();
+
+        let rs_data_contract = DataContract::try_from_platform_versioned(
+            data_contract_serialization_format.clone(),
+            full_validation.unwrap_or(false),
+            &mut validation_operations,
+            &platform_version.into(),
+        )
+        .with_js_error()?;
+
+        Ok(DataContractWASM::from(rs_data_contract))
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        let rs_state_transition = StateTransition::from(self.0.clone());
+
+        StateTransitionWASM::from(rs_state_transition)
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        state_transition: &StateTransitionWASM,
+    ) -> Result<DataContractUpdateTransitionWASM, JsValue> {
+        let rs_transition = StateTransition::from(state_transition.clone());
+
+        match rs_transition {
+            StateTransition::DataContractUpdate(state_transition) => {
+                Ok(DataContractUpdateTransitionWASM(state_transition))
+            }
+            _ => Err(JsValue::from("Incorrect transition type")),
+        }
+    }
+}

package/packages/document/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_document"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
@@ -14,9 +14,4 @@ pshenmic_dpp_data_contract = {path = "../data_contract"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "document-value-conversion"
 ]}
-#serde = { version = "1.0.197", features = ["derive"] }
-serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
-
-[profile.release]
-lto = true
-opt-level = 'z'
+serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }

package/packages/document/src/lib.rs

@@ -1,4 +1,4 @@
-mod methods;
+pub mod methods;
 
 use dpp::document::{Document, DocumentV0, DocumentV0Getters};
 use dpp::identifier::Identifier;

package/packages/document/src/methods/mod.rs

@@ -1,2 +1,370 @@
-mod js;
-mod rust;
+use crate::DocumentWASM;
+use dpp::ProtocolError;
+use dpp::dashcore::hashes::serde::Serialize;
+use dpp::data_contract::JsonValue;
+use dpp::document::Document;
+use dpp::document::serialization_traits::DocumentPlatformConversionMethodsV0;
+use dpp::identifier::Identifier;
+use dpp::platform_value::Value;
+use dpp::platform_value::converter::serde_json::BTreeValueJsonConverter;
+use dpp::prelude::Revision;
+use dpp::util::entropy_generator;
+use dpp::util::entropy_generator::EntropyGenerator;
+use pshenmic_dpp_data_contract::DataContractWASM;
+use pshenmic_dpp_enums::platform::PlatformVersionWASM;
+use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError, identifier_from_js_value};
+use std::collections::BTreeMap;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen]
+impl DocumentWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        js_raw_document: JsValue,
+        js_document_type_name: &str,
+        js_revision: u64,
+        js_data_contract_id: JsValue,
+        js_owner_id: JsValue,
+        js_document_id: JsValue,
+    ) -> Result<DocumentWASM, JsValue> {
+        let revision = Revision::from(js_revision);
+
+        let document = js_raw_document
+            .with_serde_to_platform_value_map()
+            .expect("cannot convert document to platform value map");
+
+        let owner_id = identifier_from_js_value(&js_owner_id)?;
+        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
+        let revision = Revision::from(revision);
+
+        let entropy = entropy_generator::DefaultEntropyGenerator
+            .generate()
+            .unwrap();
+
+        let document_id: Identifier = {
+            if JsValue::UNDEFINED == js_document_id {
+                pshenmic_dpp_utils::generate_document_id_v0(
+                    &data_contract_id,
+                    &owner_id,
+                    js_document_type_name,
+                    &entropy,
+                )
+            } else {
+                identifier_from_js_value(&js_document_id)
+            }
+        }?;
+
+        Ok(DocumentWASM {
+            owner_id,
+            entropy: Some(entropy),
+            id: document_id,
+            document_type_name: js_document_type_name.to_string(),
+            data_contract_id,
+            properties: document,
+            revision: Some(revision),
+            created_at: None,
+            updated_at: None,
+            transferred_at: None,
+            created_at_block_height: None,
+            updated_at_block_height: None,
+            transferred_at_block_height: None,
+            created_at_core_block_height: None,
+            updated_at_core_block_height: None,
+            transferred_at_core_block_height: None,
+        })
+    }
+
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> Vec<u8> {
+        self.id.to_vec()
+    }
+
+    #[wasm_bindgen(js_name=getEntropy)]
+    pub fn get_entropy(&self) -> Option<Vec<u8>> {
+        match self.entropy {
+            Some(entropy) => Some(entropy.to_vec()),
+            None => None,
+        }
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn get_data_contract_id(&self) -> Vec<u8> {
+        self.data_contract_id.to_vec()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> Vec<u8> {
+        self.owner_id.to_vec()
+    }
+
+    #[wasm_bindgen(js_name=getProperties)]
+    pub fn get_properties(&self) -> Result<JsValue, JsValue> {
+        let json_value: JsonValue = self
+            .properties
+            .clone()
+            .to_json_value()
+            .map_err(ProtocolError::ValueError)
+            .with_js_error()?;
+
+        let js_value = json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?;
+        Ok(js_value)
+    }
+
+    #[wasm_bindgen(js_name=getRevision)]
+    pub fn get_revision(&self) -> Option<u64> {
+        self.revision
+    }
+
+    #[wasm_bindgen(js_name=getCreatedAt)]
+    pub fn get_created_at(&self) -> Option<u64> {
+        self.created_at
+    }
+
+    #[wasm_bindgen(js_name=getUpdatedAt)]
+    pub fn get_updated_at(&self) -> Option<u64> {
+        self.updated_at
+    }
+
+    #[wasm_bindgen(js_name=getTransferredAt)]
+    pub fn get_transferred_at(&self) -> Option<u64> {
+        self.transferred_at
+    }
+
+    #[wasm_bindgen(js_name=getCreatedAtBlockHeight)]
+    pub fn get_created_at_block_height(&self) -> Option<u64> {
+        self.created_at_block_height
+    }
+
+    #[wasm_bindgen(js_name=getUpdatedAtBlockHeight)]
+    pub fn get_updated_at_block_height(&self) -> Option<u64> {
+        self.updated_at_block_height
+    }
+
+    #[wasm_bindgen(js_name=getTransferredAtBlockHeight)]
+    pub fn get_transferred_at_block_height(&self) -> Option<u64> {
+        self.transferred_at_block_height
+    }
+
+    #[wasm_bindgen(js_name=getCreatedAtCoreBlockHeight)]
+    pub fn get_created_at_core_block_height(&self) -> Option<u32> {
+        self.created_at_core_block_height
+    }
+
+    #[wasm_bindgen(js_name=getUpdatedAtCoreBlockHeight)]
+    pub fn get_updated_at_core_block_height(&self) -> Option<u32> {
+        self.updated_at_core_block_height
+    }
+
+    #[wasm_bindgen(js_name=getTransferredAtCoreBlockHeight)]
+    pub fn get_transferred_at_core_block_height(&self) -> Option<u32> {
+        self.transferred_at_core_block_height
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTypeName)]
+    pub fn get_document_type_name(&self) -> String {
+        self.document_type_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=setId)]
+    pub fn set_id(&mut self, id: JsValue) {
+        self.id = identifier_from_js_value(&id).unwrap()
+    }
+
+    #[wasm_bindgen(js_name=setEntropy)]
+    pub fn set_entropy(&mut self, entropy: JsValue) {
+        match entropy.is_undefined() {
+            false => {
+                let value = entropy.with_serde_to_platform_value().unwrap();
+
+                let mut entropy = [0u8; 32];
+                let bytes = value.as_bytes().unwrap();
+                let len = bytes.len().min(32);
+                entropy[..len].copy_from_slice(&bytes[..len]);
+                self.entropy = Some(entropy);
+            }
+            true => self.entropy = None,
+        }
+    }
+
+    #[wasm_bindgen(js_name=setOwnerId)]
+    pub fn set_owner_id(&mut self, id: JsValue) {
+        self.owner_id = identifier_from_js_value(&id).unwrap()
+    }
+
+    #[wasm_bindgen(js_name=setProperties)]
+    pub fn set_properties(&mut self, properties: JsValue) {
+        self.properties = properties.with_serde_to_platform_value_map().unwrap()
+    }
+
+    #[wasm_bindgen(js_name=setRevision)]
+    pub fn set_revision(&mut self, revision: Option<u64>) {
+        self.revision = revision
+    }
+
+    #[wasm_bindgen(js_name=setCreatedAt)]
+    pub fn set_created_at(&mut self, created_at: Option<u64>) {
+        self.created_at = created_at
+    }
+
+    #[wasm_bindgen(js_name=setUpdatedAt)]
+    pub fn set_get_updated_at(&mut self, updated_at: Option<u64>) {
+        self.updated_at = updated_at
+    }
+
+    #[wasm_bindgen(js_name=setTransferredAt)]
+    pub fn set_transferred_at(&mut self, transferred_at: Option<u64>) {
+        self.transferred_at = transferred_at
+    }
+
+    #[wasm_bindgen(js_name=setCreatedAtBlockHeight)]
+    pub fn set_created_at_block_height(&mut self, created_at_block_height: Option<u64>) {
+        self.created_at_block_height = created_at_block_height
+    }
+
+    #[wasm_bindgen(js_name=setUpdatedAtBlockHeight)]
+    pub fn set_updated_at_block_height(&mut self, updated_at_block_height: Option<u64>) {
+        self.updated_at_block_height = updated_at_block_height
+    }
+
+    #[wasm_bindgen(js_name=setTransferredAtBlockHeight)]
+    pub fn set_transferred_at_block_height(&mut self, transferred_at_block_height: Option<u64>) {
+        self.transferred_at_block_height = transferred_at_block_height
+    }
+
+    #[wasm_bindgen(js_name=setCreatedAtCoreBlockHeight)]
+    pub fn set_created_at_core_block_height(&mut self, created_at_core_block_height: Option<u32>) {
+        self.created_at_core_block_height = created_at_core_block_height
+    }
+
+    #[wasm_bindgen(js_name=setUpdatedAtCoreBlockHeight)]
+    pub fn set_updated_at_core_block_height(&mut self, updated_at_core_block_height: Option<u32>) {
+        self.updated_at_core_block_height = updated_at_core_block_height
+    }
+
+    #[wasm_bindgen(js_name=setTransferredAtCoreBlockHeight)]
+    pub fn set_transferred_at_core_block_height(
+        &mut self,
+        transferred_at_core_block_height: Option<u32>,
+    ) {
+        self.transferred_at_core_block_height = transferred_at_core_block_height
+    }
+
+    #[wasm_bindgen(js_name=setDocumentTypeName)]
+    pub fn set_document_type_name(&mut self, document_type_name: &str) {
+        self.document_type_name = document_type_name.to_string();
+    }
+
+    #[wasm_bindgen(js_name=toBytes)]
+    pub fn to_bytes(
+        &self,
+        data_contract: &DataContractWASM,
+        type_name: String,
+        js_platform_version: JsValue,
+    ) -> Result<Vec<u8>, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let rs_document: Document = Document::from(self.clone());
+
+        let document_type_ref = data_contract
+            .get_document_type_ref_by_name(type_name)
+            .map_err(|err| JsValue::from_str(err.to_string().as_str()))?;
+
+        DocumentPlatformConversionMethodsV0::serialize(
+            &rs_document,
+            document_type_ref,
+            &platform_version.into(),
+        )
+        .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=fromBytes)]
+    pub fn from_bytes(
+        bytes: Vec<u8>,
+        data_contract: &DataContractWASM,
+        type_name: String,
+        js_platform_version: JsValue,
+    ) -> Result<DocumentWASM, JsValue> {
+        let platform_version = match js_platform_version.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version)?,
+        };
+
+        let document_type_ref = match data_contract.get_document_type_ref_by_name(type_name) {
+            Ok(type_ref) => Ok(type_ref),
+            Err(err) => Err(JsValue::from_str(err.to_string().as_str())),
+        }?;
+
+        let rs_document = Document::from_bytes(
+            bytes.as_slice(),
+            document_type_ref,
+            &platform_version.into(),
+        )
+        .with_js_error();
+
+        match rs_document {
+            Ok(doc) => Ok(DocumentWASM::from(doc)),
+            Err(err) => Err(err),
+        }
+    }
+
+    #[wasm_bindgen(js_name=generateId)]
+    pub fn generate_id(
+        js_document_type_name: &str,
+        js_owner_id: JsValue,
+        js_data_contract_id: JsValue,
+        opt_entropy: Option<Vec<u8>>,
+    ) -> Result<Vec<u8>, JsValue> {
+        let owner_id = identifier_from_js_value(&js_owner_id)?;
+        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
+        let entropy: [u8; 32] = match opt_entropy {
+            Some(entropy_vec) => {
+                let mut entropy = [0u8; 32];
+                let bytes = entropy_vec.as_slice();
+                let len = bytes.len().min(32);
+                entropy[..len].copy_from_slice(&bytes[..len]);
+                entropy
+            }
+            None => entropy_generator::DefaultEntropyGenerator
+                .generate()
+                .with_js_error()?,
+        };
+
+        let identifier = pshenmic_dpp_utils::generate_document_id_v0(
+            &data_contract_id,
+            &owner_id,
+            js_document_type_name,
+            &entropy,
+        );
+
+        match identifier {
+            Ok(identifier) => Ok(identifier.to_vec()),
+            Err(err) => Err(err),
+        }
+    }
+}
+
+impl DocumentWASM {
+    pub fn rs_get_owner_id(&self) -> Identifier {
+        self.owner_id
+    }
+
+    pub fn rs_get_id(&self) -> Identifier {
+        self.id
+    }
+
+    pub fn rs_get_data_contract_id(&self) -> Identifier {
+        self.data_contract_id
+    }
+
+    pub fn rs_get_entropy(&self) -> Option<[u8; 32]> {
+        self.entropy
+    }
+
+    pub fn rs_get_properties(&self) -> BTreeMap<String, Value> {
+        self.clone().properties
+    }
+}

package/packages/documents_batch/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "pshenmic_dpp_documents_batch"
+version.workspace = true
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
+pshenmic_dpp_document = {path = "../document"}
+pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_state_transition = {path = "../state_transition"}
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "document-json-conversion",
+]}
+js-sys = "0.3.77"
+serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }

package/packages/documents_batch/src/document_base_transition/mod.rs

@@ -0,0 +1,92 @@
+use dpp::prelude::IdentityNonce;
+use dpp::state_transition::documents_batch_transition::document_base_transition::DocumentBaseTransition;
+use dpp::state_transition::documents_batch_transition::document_base_transition::v0::DocumentBaseTransitionV0;
+use dpp::state_transition::documents_batch_transition::document_base_transition::v0::v0_methods::DocumentBaseTransitionV0Methods;
+use pshenmic_dpp_utils::identifier_from_js_value;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[derive(Clone)]
+#[wasm_bindgen(js_name = "DocumentBaseTransitionWASM")]
+pub struct DocumentBaseTransitionWASM(DocumentBaseTransition);
+
+impl From<DocumentBaseTransition> for DocumentBaseTransitionWASM {
+    fn from(v: DocumentBaseTransition) -> Self {
+        DocumentBaseTransitionWASM(v)
+    }
+}
+
+impl From<DocumentBaseTransitionWASM> for DocumentBaseTransition {
+    fn from(v: DocumentBaseTransitionWASM) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen]
+impl DocumentBaseTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        js_document_id: JsValue,
+        identity_contract_nonce: IdentityNonce,
+        document_type_name: String,
+        js_data_contract_id: JsValue,
+    ) -> Result<DocumentBaseTransitionWASM, JsValue> {
+        let document_id = identifier_from_js_value(&js_document_id)?;
+        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
+
+        let rs_base_v0 = DocumentBaseTransitionV0 {
+            id: document_id,
+            identity_contract_nonce,
+            document_type_name,
+            data_contract_id,
+        };
+
+        Ok(DocumentBaseTransitionWASM(DocumentBaseTransition::from(
+            rs_base_v0,
+        )))
+    }
+
+    #[wasm_bindgen(getter = "id")]
+    pub fn get_id(&self) -> Vec<u8> {
+        self.0.id().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "identityContractNonce")]
+    pub fn get_identity_contract_nonce(&self) -> IdentityNonce {
+        self.0.identity_contract_nonce()
+    }
+
+    #[wasm_bindgen(getter = "dataContractId")]
+    pub fn get_data_contract_id(&self) -> Vec<u8> {
+        self.0.data_contract_id().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "documentTypeName")]
+    pub fn get_document_type_name(&self) -> String {
+        self.0.document_type_name().to_string()
+    }
+
+    #[wasm_bindgen(setter = "id")]
+    pub fn set_id(&mut self, js_id: JsValue) -> Result<(), JsValue> {
+        let id = identifier_from_js_value(&js_id)?;
+
+        Ok(self.0.set_id(id))
+    }
+
+    #[wasm_bindgen(setter = "identityContractNonce")]
+    pub fn set_identity_contract_nonce(&mut self, nonce: IdentityNonce) {
+        self.0.set_identity_contract_nonce(nonce)
+    }
+
+    #[wasm_bindgen(setter = "dataContractId")]
+    pub fn set_data_contract_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_data_contract_id(data_contract_id))
+    }
+
+    #[wasm_bindgen(setter = "documentTypeName")]
+    pub fn set_document_type_name(&mut self, document_type_name: String) {
+        self.0.set_document_type_name(document_type_name)
+    }
+}