pshenmic-dpp 1.0.0

package/packages/document_batch/src/lib.rs

@@ -0,0 +1,326 @@
+use crate::generators::{
+    generate_create_transition, generate_delete_transition, generate_replace_transition,
+};
+use dpp::document::{Document, DocumentV0};
+use dpp::identity::KeyType;
+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_create_transition::v0::v0_methods::DocumentCreateTransitionV0Methods;
+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, StateTransitionIdentitySigned, StateTransitionLike};
+use pshenmic_dpp_document::DocumentWASM;
+use pshenmic_dpp_enums::batch::batch_enum::BatchType;
+use pshenmic_dpp_enums::keys::key_type::KeyTypeWASM;
+use pshenmic_dpp_mock_bls::MockBLS;
+use pshenmic_dpp_private_key::PrivateKeyWASM;
+use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
+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,
+}
+
+#[wasm_bindgen]
+impl DocumentBatchWASM {
+    #[wasm_bindgen(js_name=new)]
+    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=sign)]
+    pub fn sign(
+        &mut self,
+        private_key: PrivateKeyWASM,
+        public_key: IdentityPublicKeyWASM,
+    ) -> Result<JsValue, JsValue> {
+        let mut st = StateTransition::from(self.batch.clone());
+
+        let sig = st.sign(
+            &public_key.get_key(),
+            private_key.get_key().to_bytes().as_slice(),
+            &MockBLS {},
+        );
+
+        let bytes = match sig {
+            Ok(_sig) => {
+                self.batch.set_signature(st.signature().clone());
+                self.batch
+                    .set_signature_public_key_id(st.signature_public_key_id().unwrap());
+                st.serialize_to_bytes()
+            }
+            Err(e) => wasm_bindgen::throw_str(&e.to_string()),
+        };
+
+        match bytes {
+            Ok(bytes) => Ok(JsValue::from(bytes.clone())),
+            Err(e) => Ok(JsValue::from_str(&format!("{}", e))),
+        }
+    }
+
+    #[wasm_bindgen(js_name=signByPrivateKey)]
+    pub fn sign_by_private_key(
+        &mut self,
+        private_key: PrivateKeyWASM,
+        key_type: KeyTypeWASM,
+    ) -> JsValue {
+        let mut st = StateTransition::from(self.batch.clone());
+
+        let _sig = st
+            .sign_by_private_key(
+                &private_key.get_key().to_bytes().as_slice(),
+                KeyType::from(key_type),
+                &MockBLS {},
+            )
+            .with_js_error();
+
+        self.batch.set_signature(st.signature().clone());
+        self.batch
+            .set_signature_public_key_id(st.signature_public_key_id().unwrap());
+
+        let bytes = st.serialize_to_bytes().with_js_error();
+
+        match bytes {
+            Ok(bytes) => JsValue::from(bytes.clone()),
+            Err(err) => err,
+        }
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self) -> Result<JsValue, JsValue> {
+        let bytes = &StateTransition::from(self.batch.clone())
+            .serialize_to_bytes()
+            .expect("Serialization failed");
+
+        Ok(JsValue::from(bytes.clone()))
+    }
+
+    #[wasm_bindgen(js_name=fromBuffer)]
+    pub fn from_buffer(bytes: Vec<u8>) -> Result<DocumentBatchWASM, JsValue> {
+        let batch = &StateTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error()?;
+
+        match batch {
+            StateTransition::DocumentsBatch(batch) => {
+                let transition = batch.transitions().first();
+
+                match transition {
+                    None => Err(JsValue::from_str("No transition")),
+                    Some(document_transition) => {
+                        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 document: DocumentV0 = match document_transition {
+                            DocumentTransition::Create(create_transition) => DocumentV0 {
+                                id: document_transition.get_id(),
+                                owner_id: batch.owner_id(),
+                                properties: create_transition.data().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,
+                            },
+                            DocumentTransition::Replace(_replace_transition) => DocumentV0 {
+                                id: document_transition.get_id(),
+                                owner_id: batch.owner_id(),
+                                properties: BTreeMap::new(),
+                                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,
+                            },
+                            DocumentTransition::Delete(_delete_transition) => DocumentV0 {
+                                id: document_transition.get_id(),
+                                owner_id: batch.owner_id(),
+                                properties: BTreeMap::new(),
+                                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,
+                            },
+                            DocumentTransition::Transfer(_transfer_transition) => DocumentV0 {
+                                id: document_transition.get_id(),
+                                owner_id: batch.owner_id(),
+                                properties: BTreeMap::new(),
+                                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,
+                            },
+                            DocumentTransition::UpdatePrice(_update_price_transition) => {
+                                DocumentV0 {
+                                    id: document_transition.get_id(),
+                                    owner_id: batch.owner_id(),
+                                    properties: BTreeMap::new(),
+                                    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,
+                                }
+                            }
+                            DocumentTransition::Purchase(_purchase_transition) => DocumentV0 {
+                                id: document_transition.get_id(),
+                                owner_id: batch.owner_id(),
+                                properties: BTreeMap::new(),
+                                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,
+                        };
+
+                        Ok(DocumentBatchWASM {
+                            batch: batch.clone(),
+                            document: DocumentWASM::from_batch(
+                                Document::V0(document),
+                                data_contract_id,
+                                document_type_name.to_string(),
+                                normal_entropy,
+                            ),
+                        })
+                    }
+                }
+            }
+            _ => Err(JsValue::from_str("incorrect batch type")),
+        }
+    }
+
+    #[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()
+    }
+}

package/packages/enums/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "pshenmic_dpp_enums"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+wasm-bindgen = "0.2.100"
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "identity-value-conversion",
+]}

package/packages/enums/src/batch/batch_enum.rs

@@ -0,0 +1,19 @@
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "BatchType")]
+pub enum BatchType {
+    CREATE,
+    REPLACE,
+    DELETE,
+}
+
+impl From<u8> for BatchType {
+    fn from(value: u8) -> Self {
+        match value {
+            0 => BatchType::CREATE,
+            1 => BatchType::REPLACE,
+            2 => BatchType::DELETE,
+            _ => panic!("Invalid BatchType"),
+        }
+    }
+}

package/packages/enums/src/batch/mod.rs

@@ -0,0 +1 @@
+pub mod batch_enum;

package/packages/enums/src/keys/key_type.rs

@@ -0,0 +1,36 @@
+use dpp::identity::KeyType;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[allow(non_camel_case_types)]
+#[wasm_bindgen(js_name = "KeyType")]
+pub enum KeyTypeWASM {
+    ECDSA_SECP256K1 = 0,
+    BLS12_381 = 1,
+    ECDSA_HASH160 = 2,
+    BIP13_SCRIPT_HASH = 3,
+    EDDSA_25519_HASH160 = 4,
+}
+
+impl From<KeyTypeWASM> for KeyType {
+    fn from(key_type: KeyTypeWASM) -> Self {
+        match key_type {
+            KeyTypeWASM::ECDSA_SECP256K1 => KeyType::ECDSA_SECP256K1,
+            KeyTypeWASM::BLS12_381 => KeyType::BLS12_381,
+            KeyTypeWASM::ECDSA_HASH160 => KeyType::ECDSA_HASH160,
+            KeyTypeWASM::BIP13_SCRIPT_HASH => KeyType::BIP13_SCRIPT_HASH,
+            KeyTypeWASM::EDDSA_25519_HASH160 => KeyType::EDDSA_25519_HASH160,
+        }
+    }
+}
+
+impl From<KeyType> for KeyTypeWASM {
+    fn from(key_type: KeyType) -> Self {
+        match key_type {
+            KeyType::ECDSA_SECP256K1 => KeyTypeWASM::ECDSA_SECP256K1,
+            KeyType::BLS12_381 => KeyTypeWASM::BLS12_381,
+            KeyType::ECDSA_HASH160 => KeyTypeWASM::ECDSA_HASH160,
+            KeyType::BIP13_SCRIPT_HASH => KeyTypeWASM::BIP13_SCRIPT_HASH,
+            KeyType::EDDSA_25519_HASH160 => KeyTypeWASM::EDDSA_25519_HASH160,
+        }
+    }
+}

package/packages/enums/src/keys/mod.rs

@@ -0,0 +1,3 @@
+pub mod key_type;
+pub mod purpose;
+pub mod security_level;

package/packages/enums/src/keys/purpose.rs

@@ -0,0 +1,41 @@
+use dpp::identity::Purpose;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "Purpose")]
+pub enum PurposeWASM {
+    AUTHENTICATION = 0,
+    ENCRYPTION = 1,
+    DECRYPTION = 2,
+    TRANSFER = 3,
+    SYSTEM = 4,
+    VOTING = 5,
+    OWNER = 6,
+}
+
+impl From<PurposeWASM> for Purpose {
+    fn from(purpose: PurposeWASM) -> Self {
+        match purpose {
+            PurposeWASM::AUTHENTICATION => Purpose::AUTHENTICATION,
+            PurposeWASM::ENCRYPTION => Purpose::ENCRYPTION,
+            PurposeWASM::DECRYPTION => Purpose::DECRYPTION,
+            PurposeWASM::TRANSFER => Purpose::TRANSFER,
+            PurposeWASM::SYSTEM => Purpose::SYSTEM,
+            PurposeWASM::VOTING => Purpose::VOTING,
+            PurposeWASM::OWNER => Purpose::OWNER,
+        }
+    }
+}
+
+impl From<Purpose> for PurposeWASM {
+    fn from(purpose: Purpose) -> Self {
+        match purpose {
+            Purpose::AUTHENTICATION => PurposeWASM::AUTHENTICATION,
+            Purpose::ENCRYPTION => PurposeWASM::ENCRYPTION,
+            Purpose::DECRYPTION => PurposeWASM::DECRYPTION,
+            Purpose::TRANSFER => PurposeWASM::TRANSFER,
+            Purpose::SYSTEM => PurposeWASM::SYSTEM,
+            Purpose::VOTING => PurposeWASM::VOTING,
+            Purpose::OWNER => PurposeWASM::OWNER,
+        }
+    }
+}

package/packages/enums/src/keys/security_level.rs

@@ -0,0 +1,32 @@
+use dpp::identity::SecurityLevel;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = SecurityLevel)]
+pub enum SecurityLevelWASM {
+    MASTER = 0,
+    CRITICAL = 1,
+    HIGH = 2,
+    MEDIUM = 3,
+}
+
+impl From<SecurityLevelWASM> for SecurityLevel {
+    fn from(security_level: SecurityLevelWASM) -> Self {
+        match security_level {
+            SecurityLevelWASM::MASTER => SecurityLevel::MASTER,
+            SecurityLevelWASM::CRITICAL => SecurityLevel::CRITICAL,
+            SecurityLevelWASM::HIGH => SecurityLevel::HIGH,
+            SecurityLevelWASM::MEDIUM => SecurityLevel::MEDIUM,
+        }
+    }
+}
+
+impl From<SecurityLevel> for SecurityLevelWASM {
+    fn from(security_level: SecurityLevel) -> Self {
+        match security_level {
+            SecurityLevel::MASTER => SecurityLevelWASM::MASTER,
+            SecurityLevel::CRITICAL => SecurityLevelWASM::CRITICAL,
+            SecurityLevel::HIGH => SecurityLevelWASM::HIGH,
+            SecurityLevel::MEDIUM => SecurityLevelWASM::MEDIUM,
+        }
+    }
+}

package/packages/enums/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod batch;
+pub mod keys;

package/packages/mock_bls/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "pshenmic_dpp_mock_bls"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "bls-signatures",
+]}

package/packages/mock_bls/src/lib.rs

@@ -0,0 +1,26 @@
+use dpp::{BlsModule, ProtocolError, PublicKeyValidationError};
+
+pub struct MockBLS {}
+
+impl BlsModule for MockBLS {
+    fn validate_public_key(&self, _pk: &[u8]) -> Result<(), PublicKeyValidationError> {
+        panic!("BLS signatures are not implemented");
+    }
+
+    fn verify_signature(
+        &self,
+        _signature: &[u8],
+        _data: &[u8],
+        _public_key: &[u8],
+    ) -> Result<bool, ProtocolError> {
+        panic!("BLS signatures are not implemented");
+    }
+
+    fn private_key_to_public_key(&self, _private_key: &[u8]) -> Result<Vec<u8>, ProtocolError> {
+        panic!("BLS signatures are not implemented");
+    }
+
+    fn sign(&self, _data: &[u8], _private_key: &[u8]) -> Result<Vec<u8>, ProtocolError> {
+        panic!("BLS signatures are not implemented");
+    }
+}

package/packages/private_key/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "pshenmic_dpp_private_key"
+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 = [
+    "identity-value-conversion",
+]}

package/packages/private_key/src/lib.rs

@@ -0,0 +1,35 @@
+use dpp::dashcore::PrivateKey;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "PrivateKeyWASM")]
+pub struct PrivateKeyWASM {
+    private_key: PrivateKey,
+}
+
+#[wasm_bindgen]
+impl PrivateKeyWASM {
+    #[wasm_bindgen(js_name = "new")]
+    pub fn new(wif: &str) -> Self {
+        let pk = PrivateKey::from_wif(wif).expect("Unable to parse private key");
+
+        PrivateKeyWASM { private_key: pk }
+    }
+}
+
+impl PrivateKeyWASM {
+    pub fn get_key(&self) -> PrivateKey {
+        self.private_key
+    }
+
+    pub fn get_key_inner(&self) -> [u8; 32] {
+        self.private_key.inner.secret_bytes()
+    }
+}
+
+#[wasm_bindgen]
+impl PrivateKeyWASM {
+    #[wasm_bindgen(js_name = "getKeyWIF")]
+    pub fn get_key_wif(&self) -> String {
+        self.private_key.to_wif()
+    }
+}

package/packages/public_key/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "pshenmic_dpp_public_key"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+js-sys = "0.3.77"
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", features = [
+    "identity-value-conversion",
+]}
+pshenmic_dpp_enums = {path = "../enums"}