pshenmic-dpp 1.0.4 → 1.0.5

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/{document_batch → documents_batch}/Cargo.toml

@@ -1,17 +1,19 @@
 [package]
-name = "pshenmic_dpp_document_batch"
-version = "0.1.0"
+name = "pshenmic_dpp_documents_batch"
+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_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)
+    }
+}

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

@@ -0,0 +1,166 @@
+use crate::transitions::create::DocumentCreateTransitionWASM;
+use crate::transitions::delete::DocumentDeleteTransitionWASM;
+use crate::transitions::purchase::DocumentPurchaseTransitionWASM;
+use crate::transitions::replace::DocumentReplaceTransitionWASM;
+use crate::transitions::transfer::DocumentTransferTransitionWASM;
+use crate::transitions::update_price::DocumentUpdatePriceTransitionWASM;
+use dpp::prelude::{Identifier, IdentityNonce, Revision};
+use dpp::state_transition::documents_batch_transition::document_transition::action_type::TransitionActionTypeGetter;
+use dpp::state_transition::documents_batch_transition::document_transition::{
+    DocumentTransition, DocumentTransitionV0Methods,
+};
+use pshenmic_dpp_enums::batch::batch_enum::BatchTypeWASM;
+use pshenmic_dpp_utils::identifier_from_js_value;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[derive(Clone)]
+#[wasm_bindgen(js_name = "DocumentTransitionWASM")]
+pub struct DocumentTransitionWASM(DocumentTransition);
+
+impl From<DocumentTransition> for DocumentTransitionWASM {
+    fn from(transition: DocumentTransition) -> Self {
+        DocumentTransitionWASM(transition)
+    }
+}
+
+impl From<DocumentTransitionWASM> for DocumentTransition {
+    fn from(transition: DocumentTransitionWASM) -> Self {
+        transition.0
+    }
+}
+
+#[wasm_bindgen]
+impl DocumentTransitionWASM {
+    #[wasm_bindgen(getter = "actionType")]
+    pub fn get_action_type(&self) -> String {
+        BatchTypeWASM::from(self.0.action_type()).into()
+    }
+
+    #[wasm_bindgen(getter = "dataContractId")]
+    pub fn get_data_contract_id(&self) -> Vec<u8> {
+        self.0.data_contract_id().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "id")]
+    pub fn get_id(&self) -> Vec<u8> {
+        self.0.get_id().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "documentTypeName")]
+    pub fn get_document_type_name(&self) -> String {
+        self.0.document_type_name().clone()
+    }
+
+    #[wasm_bindgen(getter = "identityContractNonce")]
+    pub fn get_identity_contract_nonce(&self) -> IdentityNonce {
+        self.0.identity_contract_nonce()
+    }
+
+    #[wasm_bindgen(getter = "revision")]
+    pub fn get_revision(&self) -> Option<Revision> {
+        self.0.revision()
+    }
+
+    #[wasm_bindgen(getter = "entropy")]
+    pub fn get_entropy(&self) -> Option<Vec<u8>> {
+        self.0.entropy()
+    }
+
+    #[wasm_bindgen(getter = "createTransition")]
+    pub fn get_create_transition(&self) -> Result<DocumentCreateTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Create(create) => Ok(DocumentCreateTransitionWASM::from(create)),
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "replaceTransition")]
+    pub fn get_replace_transition(&self) -> Result<DocumentReplaceTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Replace(replace) => {
+                Ok(DocumentReplaceTransitionWASM::from(replace))
+            }
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "deleteTransition")]
+    pub fn get_delete_transition(&self) -> Result<DocumentDeleteTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Delete(delete) => Ok(DocumentDeleteTransitionWASM::from(delete)),
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "purchaseTransition")]
+    pub fn get_purchase_transition(&self) -> Result<DocumentPurchaseTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Purchase(purchase) => {
+                Ok(DocumentPurchaseTransitionWASM::from(purchase))
+            }
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "transferTransition")]
+    pub fn get_transfer_transition(&self) -> Result<DocumentTransferTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::Transfer(transfer) => {
+                Ok(DocumentTransferTransitionWASM::from(transfer))
+            }
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "updatePriceTransition")]
+    pub fn get_update_price_transition(
+        &self,
+    ) -> Result<DocumentUpdatePriceTransitionWASM, JsValue> {
+        match self.0.clone() {
+            DocumentTransition::UpdatePrice(update_price) => {
+                Ok(DocumentUpdatePriceTransitionWASM::from(update_price))
+            }
+            _ => Err(JsValue::undefined()),
+        }
+    }
+
+    #[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 = "revision")]
+    pub fn set_revision(&mut self, revision: Revision) {
+        self.0.set_revision(revision)
+    }
+
+    #[wasm_bindgen(setter = "identityContractNonce")]
+    pub fn set_identity_contract_nonce(&mut self, identity_contract_nonce: IdentityNonce) {
+        self.0.set_identity_contract_nonce(identity_contract_nonce)
+    }
+}
+
+impl DocumentTransitionWASM {
+    pub fn rs_get_data_contract_id(&self) -> Identifier {
+        self.0.data_contract_id()
+    }
+
+    pub fn rs_get_id(&self) -> Identifier {
+        self.0.get_id()
+    }
+
+    pub fn rs_get_entropy(&self) -> Option<Vec<u8>> {
+        self.0.entropy()
+    }
+
+    pub fn rs_get_revision(&self) -> Option<Revision> {
+        self.0.revision()
+    }
+
+    pub fn rs_get_identity_contract_nonce(&self) -> IdentityNonce {
+        self.0.identity_contract_nonce()
+    }
+}