pshenmic-dpp 1.0.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "pshenmic-dpp",
+  "version": "1.0.0",
+  "main": "dist/wasm/pshenmic_dpp.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/owl352/pshemic-dpp"
+  },
+  "scripts": {
+    "tsc": "tsc",
+    "build:bin": "./scripts/build.sh",
+    "build:js": "./scripts/build-js.sh",
+    "build:full": "./scripts/build.sh && ./scripts/build-js.sh",
+    "build:raw": "./scripts/build.sh && RAW=true ./scripts/build-js.sh"
+  },
+  "author": "owl352",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "babel": "^6.23.0",
+    "babel-cli": "^6.26.0",
+    "typescript": "^5.8.2"
+  },
+  "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447"
+}

package/packages/cbor-conversation/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "pshenmic_dpp_document_search"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "cbor"
+]}
+pshenmic_dpp_utils = {path = "../utils"}
+base64 = "0.22.1"
+ciborium = "0.2.0"
+serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }

package/packages/cbor-conversation/src/lib.rs

@@ -0,0 +1,26 @@
+use base64::Engine;
+use base64::prelude::BASE64_STANDARD;
+use ciborium;
+use ciborium::Value;
+use dpp::util::cbor_serializer::serializable_value_to_cbor;
+use pshenmic_dpp_utils::with_serde_to_platform_value;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "objectToCbor")]
+pub fn object_to_cbor(object: &JsValue) -> String {
+    let value_object = with_serde_to_platform_value(object).unwrap();
+
+    let cbor = serializable_value_to_cbor(&value_object, None).unwrap();
+
+    BASE64_STANDARD.encode(cbor)
+}
+
+#[wasm_bindgen(js_name = "cborToObject")]
+pub fn cbor_to_object(cbor: String) -> JsValue {
+    let base64_bytes = BASE64_STANDARD.decode(cbor).unwrap();
+
+    let cbor: Value = ciborium::de::from_reader(base64_bytes.as_slice()).expect("REASON");
+
+    serde_wasm_bindgen::to_value(&cbor).unwrap()
+}

package/packages/document/Cargo.toml

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

package/packages/document/src/lib.rs

@@ -0,0 +1,58 @@
+mod methods;
+
+use dpp::document::{Document, DocumentV0Getters};
+use dpp::identifier::Identifier;
+use dpp::identity::TimestampMillis;
+use dpp::platform_value::Value;
+use dpp::prelude::{BlockHeight, CoreBlockHeight, Revision};
+use std::collections::BTreeMap;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[derive(Debug, Clone, PartialEq)]
+#[wasm_bindgen(js_name = DocumentWASM)]
+pub struct DocumentWASM {
+    id: Identifier,
+    owner_id: Identifier,
+    revision: Option<Revision>,
+    data_contract_id: Identifier,
+    document_type_name: String,
+    properties: BTreeMap<String, Value>,
+    created_at: Option<TimestampMillis>,
+    updated_at: Option<TimestampMillis>,
+    transferred_at: Option<TimestampMillis>,
+    created_at_block_height: Option<BlockHeight>,
+    updated_at_block_height: Option<BlockHeight>,
+    transferred_at_block_height: Option<BlockHeight>,
+    created_at_core_block_height: Option<CoreBlockHeight>,
+    updated_at_core_block_height: Option<CoreBlockHeight>,
+    transferred_at_core_block_height: Option<CoreBlockHeight>,
+    entropy: Option<[u8; 32]>,
+}
+
+impl DocumentWASM {
+    pub fn from_batch(
+        document: Document,
+        data_contract_id: Identifier,
+        document_type_name: String,
+        entropy: Option<[u8; 32]>,
+    ) -> Self {
+        DocumentWASM {
+            id: document.id(),
+            owner_id: document.owner_id(),
+            revision: document.revision(),
+            data_contract_id,
+            document_type_name,
+            properties: document.properties().clone(),
+            created_at: document.created_at(),
+            updated_at: document.updated_at(),
+            transferred_at: document.transferred_at(),
+            created_at_block_height: document.created_at_block_height(),
+            updated_at_block_height: document.updated_at_block_height(),
+            transferred_at_block_height: document.transferred_at_block_height(),
+            created_at_core_block_height: document.created_at_core_block_height(),
+            updated_at_core_block_height: document.updated_at_core_block_height(),
+            transferred_at_core_block_height: document.transferred_at_core_block_height(),
+            entropy,
+        }
+    }
+}

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

@@ -0,0 +1,204 @@
+use crate::DocumentWASM;
+use dpp::platform_value::converter::serde_json::BTreeValueJsonConverter;
+use dpp::platform_value::string_encoding::Encoding::Base58;
+use dpp::prelude::Revision;
+use pshenmic_dpp_utils::{ToSerdeJSONExt, identifier_from_js_value};
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen]
+impl DocumentWASM {
+    #[wasm_bindgen(js_name=new)]
+    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) -> JsValue {
+        let json = &self.properties.to_json_value().unwrap();
+
+        let obj = json.as_object().unwrap();
+
+        serde_wasm_bindgen::to_value(obj).unwrap()
+    }
+
+    #[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();
+    }
+}

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

@@ -0,0 +1,2 @@
+mod js;
+mod rust;

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

@@ -0,0 +1,92 @@
+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/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "pshenmic_dpp_document_batch"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+pshenmic_dpp_document = {path = "../document"}
+pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_public_key = {path = "../public_key"}
+pshenmic_dpp_private_key = {path = "../private_key"}
+pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_mock_bls = {path = "../mock_bls"}
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "document-json-conversion",
+    "state-transition-signing"
+]}

package/packages/document_batch/src/generators.rs

@@ -0,0 +1,63 @@
+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(),
+    })
+}