pshenmic-dpp 1.0.4 → 1.0.5

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

@@ -1,260 +0,0 @@
-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::platform_value::converter::serde_json::BTreeValueJsonConverter;
-use dpp::platform_value::string_encoding::Encoding::Base58;
-use dpp::prelude::Revision;
-use pshenmic_dpp_data_contract::DataContractWASM;
-use pshenmic_dpp_enums::platform::PlatformVersionWASM;
-use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError, identifier_from_js_value};
-use wasm_bindgen::JsValue;
-use wasm_bindgen::prelude::wasm_bindgen;
-
-#[wasm_bindgen]
-impl DocumentWASM {
-    #[wasm_bindgen(constructor)]
-    pub fn js_new(
-        js_raw_document: JsValue,
-        js_document_type_name: &str,
-        js_revision: u64,
-        js_data_contract_id: &str,
-        js_owner_id: &str,
-    ) -> Self {
-        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");
-
-        DocumentWASM::new(
-            document,
-            js_document_type_name,
-            revision,
-            js_data_contract_id,
-            js_owner_id,
-        )
-    }
-
-    #[wasm_bindgen(js_name=getId)]
-    pub fn js_get_id(&self) -> JsValue {
-        JsValue::from_str(self.id.to_string(Base58).as_str())
-    }
-
-    #[wasm_bindgen(js_name=getEntropy)]
-    pub fn js_get_entropy(&self) -> JsValue {
-        match self.entropy {
-            Some(_entropy) => JsValue::from(self.entropy.unwrap().to_vec()),
-            None => JsValue::undefined(),
-        }
-    }
-
-    #[wasm_bindgen(js_name=getOwnerId)]
-    pub fn js_get_owner_id(&self) -> JsValue {
-        JsValue::from_str(self.owner_id.to_string(Base58).as_str())
-    }
-
-    #[wasm_bindgen(js_name=getProperties)]
-    pub fn js_get_properties(&self) -> Result<JsValue, JsValue> {
-        let json_value: JsonValue = self
-            .properties
-            .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 js_set_id(&mut self, id: JsValue) {
-        self.id = identifier_from_js_value(&id).unwrap()
-    }
-
-    #[wasm_bindgen(js_name=setEntropy)]
-    pub fn js_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 js_set_owner_id(&mut self, id: JsValue) {
-        self.owner_id = identifier_from_js_value(&id).unwrap()
-    }
-
-    #[wasm_bindgen(js_name=setProperties)]
-    pub fn js_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,
-        platform_version: PlatformVersionWASM,
-    ) -> Result<Vec<u8>, JsValue> {
-        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,
-        platform_version: PlatformVersionWASM,
-    ) -> Result<DocumentWASM, JsValue> {
-        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),
-        }
-    }
-}

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

@@ -1,92 +0,0 @@
-use crate::DocumentWASM;
-use dpp::identifier::Identifier;
-use dpp::platform_value::Value;
-use dpp::platform_value::string_encoding::Encoding::Base58;
-use dpp::prelude::Revision;
-use dpp::util::entropy_generator;
-use dpp::util::entropy_generator::EntropyGenerator;
-use std::collections::BTreeMap;
-
-impl DocumentWASM {
-    pub fn new(
-        document: BTreeMap<String, Value>,
-        document_type_name: &str,
-        revision: u64,
-        data_contract_id: &str,
-        owner_id: &str,
-    ) -> Self {
-        let owner_id = Identifier::from_string(owner_id, Base58).unwrap();
-        let data_contract_id = Identifier::from_string(data_contract_id, Base58).unwrap();
-        let revision = Revision::from(revision);
-
-        let entropy = entropy_generator::DefaultEntropyGenerator
-            .generate()
-            .unwrap();
-
-        let document_id = pshenmic_dpp_utils::generate_document_id_v0(
-            &data_contract_id,
-            &owner_id,
-            document_type_name,
-            &entropy,
-        );
-
-        DocumentWASM {
-            owner_id,
-            entropy: Some(entropy),
-            id: document_id,
-            document_type_name: 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,
-        }
-    }
-
-    pub fn get_id(&self) -> Identifier {
-        self.id
-    }
-
-    pub fn get_entropy(&self) -> Option<[u8; 32]> {
-        self.entropy
-    }
-
-    pub fn get_data_contract_id(&self) -> Identifier {
-        self.data_contract_id
-    }
-
-    pub fn get_owner_id(&self) -> Identifier {
-        self.owner_id
-    }
-
-    pub fn get_properties(&self) -> BTreeMap<String, Value> {
-        self.properties.clone()
-    }
-
-    pub fn set_id(&mut self, id: Identifier) {
-        self.id = id
-    }
-
-    pub fn set_entropy(&mut self, entropy: Option<[u8; 32]>) {
-        self.entropy = entropy;
-    }
-
-    pub fn set_data_contract_id(&mut self, data_contract_id: Identifier) {
-        self.data_contract_id = data_contract_id
-    }
-
-    pub fn set_owner_id(&mut self, id: Identifier) {
-        self.owner_id = id
-    }
-
-    pub fn set_properties(&mut self, properties: BTreeMap<String, Value>) {
-        self.properties = properties
-    }
-}

package/packages/document_batch/src/generators.rs

@@ -1,63 +0,0 @@
-use dpp::prelude::{Identifier, 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_create_transition::DocumentCreateTransitionV0;
-use dpp::state_transition::documents_batch_transition::document_delete_transition::DocumentDeleteTransitionV0;
-use dpp::state_transition::documents_batch_transition::document_replace_transition::DocumentReplaceTransitionV0;
-use dpp::state_transition::documents_batch_transition::{
-    DocumentCreateTransition, DocumentDeleteTransition, DocumentReplaceTransition,
-};
-use pshenmic_dpp_document::DocumentWASM;
-
-pub fn generate_create_transition(
-    document: DocumentWASM,
-    identity_contract_nonce: IdentityNonce,
-    document_type_name: String,
-    data_contract_id: Identifier,
-) -> DocumentCreateTransition {
-    DocumentCreateTransition::V0(DocumentCreateTransitionV0 {
-        base: DocumentBaseTransition::V0(DocumentBaseTransitionV0 {
-            id: document.get_id(),
-            identity_contract_nonce,
-            document_type_name,
-            data_contract_id,
-        }),
-        entropy: document.get_entropy().unwrap(),
-        data: document.get_properties(),
-        prefunded_voting_balance: None,
-    })
-}
-
-pub fn generate_delete_transition(
-    document: DocumentWASM,
-    identity_contract_nonce: IdentityNonce,
-    document_type_name: String,
-    data_contract_id: Identifier,
-) -> DocumentDeleteTransition {
-    DocumentDeleteTransition::V0(DocumentDeleteTransitionV0 {
-        base: DocumentBaseTransition::V0(DocumentBaseTransitionV0 {
-            id: document.get_id(),
-            identity_contract_nonce,
-            document_type_name,
-            data_contract_id,
-        }),
-    })
-}
-
-pub fn generate_replace_transition(
-    document: DocumentWASM,
-    identity_contract_nonce: IdentityNonce,
-    document_type_name: String,
-    data_contract_id: Identifier,
-) -> DocumentReplaceTransition {
-    DocumentReplaceTransition::V0(DocumentReplaceTransitionV0 {
-        base: DocumentBaseTransition::V0(DocumentBaseTransitionV0 {
-            id: document.get_id(),
-            identity_contract_nonce,
-            document_type_name,
-            data_contract_id,
-        }),
-        revision: document.get_revision().unwrap(),
-        data: document.get_properties(),
-    })
-}

package/packages/document_batch/src/lib.rs

@@ -1,228 +0,0 @@
-use crate::generators::{
-    generate_create_transition, generate_delete_transition, generate_replace_transition,
-};
-use dpp::document::{Document, DocumentV0};
-use dpp::prelude::IdentityNonce;
-use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
-use dpp::state_transition::documents_batch_transition::accessors::DocumentsBatchTransitionAccessorsV0;
-use dpp::state_transition::documents_batch_transition::document_base_transition::v0::v0_methods::DocumentBaseTransitionV0Methods;
-use dpp::state_transition::documents_batch_transition::document_transition::{
-    DocumentTransition, DocumentTransitionV0Methods,
-};
-use dpp::state_transition::documents_batch_transition::{
-    DocumentCreateTransition, DocumentDeleteTransition, DocumentReplaceTransition,
-    DocumentsBatchTransition, DocumentsBatchTransitionV0,
-};
-use dpp::state_transition::{StateTransition, StateTransitionLike};
-use pshenmic_dpp_document::DocumentWASM;
-use pshenmic_dpp_enums::batch::batch_enum::BatchType;
-use pshenmic_dpp_state_transition::StateTransitionWASM;
-use pshenmic_dpp_utils::WithJsError;
-use std::collections::BTreeMap;
-use wasm_bindgen::JsValue;
-use wasm_bindgen::prelude::wasm_bindgen;
-
-mod generators;
-
-#[derive(Debug, Clone, PartialEq)]
-#[wasm_bindgen(js_name=DocumentBatchWASM)]
-pub struct DocumentBatchWASM {
-    batch: DocumentsBatchTransition,
-    document: DocumentWASM,
-}
-
-impl From<(DocumentTransition, DocumentsBatchTransition)> for DocumentBatchWASM {
-    fn from(
-        (document_transition, batch): (DocumentTransition, DocumentsBatchTransition),
-    ) -> DocumentBatchWASM {
-        let data_contract_id = document_transition.base().data_contract_id();
-        let document_type_name = document_transition.base().document_type_name();
-        let entropy = document_transition.entropy();
-
-        let default = BTreeMap::new();
-        let properties = document_transition.data().unwrap_or(&default);
-
-        let document = DocumentV0 {
-            id: document_transition.get_id(),
-            owner_id: batch.owner_id(),
-            properties: properties.clone(),
-            revision: document_transition.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,
-        };
-
-        let normal_entropy = match entropy {
-            Some(entropy) => {
-                let mut entropy_sized = [0u8; 32];
-                let bytes = entropy.as_slice();
-                let len = bytes.len().min(32);
-                entropy_sized[..len].copy_from_slice(&bytes[..len]);
-                Some(entropy_sized)
-            }
-            None => None,
-        };
-
-        DocumentBatchWASM {
-            batch: batch.clone(),
-            document: DocumentWASM::from_batch(
-                Document::V0(document),
-                data_contract_id,
-                document_type_name.to_string(),
-                normal_entropy,
-            ),
-        }
-    }
-}
-
-#[wasm_bindgen]
-impl DocumentBatchWASM {
-    #[wasm_bindgen(constructor)]
-    pub fn new(
-        batch_type: BatchType,
-        document: DocumentWASM,
-        identity_contract_nonce: IdentityNonce,
-    ) -> Result<DocumentBatchWASM, JsValue> {
-        let data_contract_id = document.get_data_contract_id();
-        let document_type_name = document.get_document_type_name();
-
-        match document.get_entropy() {
-            Some(_entropy) => Ok(match batch_type {
-                BatchType::CREATE => {
-                    let create_transition: DocumentCreateTransition = generate_create_transition(
-                        document.clone(),
-                        identity_contract_nonce,
-                        document_type_name.to_string(),
-                        data_contract_id,
-                    );
-
-                    DocumentBatchWASM {
-                        batch: DocumentsBatchTransition::V0(DocumentsBatchTransitionV0 {
-                            owner_id: document.get_owner_id(),
-                            transitions: [DocumentTransition::Create(create_transition)].to_vec(),
-                            user_fee_increase: 0,
-                            signature_public_key_id: 0,
-                            signature: Default::default(),
-                        }),
-                        document,
-                    }
-                }
-                BatchType::DELETE => {
-                    let delete_transition: DocumentDeleteTransition = generate_delete_transition(
-                        document.clone(),
-                        identity_contract_nonce,
-                        document_type_name.to_string(),
-                        data_contract_id,
-                    );
-
-                    DocumentBatchWASM {
-                        batch: DocumentsBatchTransition::V0(DocumentsBatchTransitionV0 {
-                            owner_id: document.get_owner_id(),
-                            transitions: [DocumentTransition::Delete(delete_transition)].to_vec(),
-                            user_fee_increase: 0,
-                            signature_public_key_id: 0,
-                            signature: Default::default(),
-                        }),
-                        document,
-                    }
-                }
-                BatchType::REPLACE => {
-                    let replace_transition: DocumentReplaceTransition = generate_replace_transition(
-                        document.clone(),
-                        identity_contract_nonce,
-                        document_type_name.to_string(),
-                        data_contract_id,
-                    );
-
-                    DocumentBatchWASM {
-                        batch: DocumentsBatchTransition::V0(DocumentsBatchTransitionV0 {
-                            owner_id: document.get_owner_id(),
-                            transitions: [DocumentTransition::Replace(replace_transition)].to_vec(),
-                            user_fee_increase: 0,
-                            signature_public_key_id: 0,
-                            signature: Default::default(),
-                        }),
-                        document,
-                    }
-                }
-            }),
-            None => wasm_bindgen::throw_str("Entropy is empty"),
-        }
-    }
-
-    #[wasm_bindgen(js_name=toStateTransition)]
-    pub fn to_state_transition(&self) -> StateTransitionWASM {
-        let st = StateTransition::from(self.batch.clone());
-
-        StateTransitionWASM::from(st)
-    }
-
-    #[wasm_bindgen(js_name=toBytes)]
-    pub fn to_bytes(&self) -> Result<JsValue, JsValue> {
-        let bytes = self.batch.serialize_to_bytes().with_js_error();
-
-        match bytes {
-            Ok(bytes) => Ok(JsValue::from(bytes.clone())),
-            Err(err) => Err(err),
-        }
-    }
-
-    #[wasm_bindgen(js_name=fromStateTransition)]
-    pub fn from_state_transition(
-        state_transition: StateTransitionWASM,
-    ) -> Result<DocumentBatchWASM, JsValue> {
-        let rs_st = StateTransition::from(state_transition);
-
-        match rs_st {
-            StateTransition::DocumentsBatch(batch) => {
-                let transition = batch.transitions().first();
-
-                match transition {
-                    None => Err(JsValue::from_str("No transition")),
-                    Some(document_transition) => Ok(DocumentBatchWASM::from((
-                        document_transition.clone(),
-                        batch,
-                    ))),
-                }
-            }
-            _ => Err(JsValue::from_str("Invalid state transition")),
-        }
-    }
-
-    #[wasm_bindgen(js_name=fromBytes)]
-    pub fn from_bytes(bytes: Vec<u8>) -> Result<DocumentBatchWASM, JsValue> {
-        let batch_transition =
-            DocumentsBatchTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error();
-
-        match batch_transition {
-            Ok(batch) => {
-                let transition = batch.transitions().first();
-
-                match transition {
-                    None => Err(JsValue::from_str("No transition")),
-                    Some(document_transition) => Ok(DocumentBatchWASM::from((
-                        document_transition.clone(),
-                        batch,
-                    ))),
-                }
-            }
-            Err(err) => Err(err),
-        }
-    }
-
-    #[wasm_bindgen(js_name=getDocument)]
-    pub fn get_document(&self) -> DocumentWASM {
-        self.document.clone()
-    }
-
-    #[wasm_bindgen(js_name=getSignature)]
-    pub fn get_signature(&self) -> Vec<u8> {
-        self.batch.signature().to_vec()
-    }
-}