pshenmic-dpp 1.0.0 → 1.0.1

package/packages/identity_transitions/src/create_transition/public_key_in_creation/mod.rs

@@ -0,0 +1,146 @@
+use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
+use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel};
+use dpp::platform_value::BinaryData;
+use dpp::platform_value::string_encoding::Encoding::Hex;
+use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
+use dpp::state_transition::public_key_in_creation::accessors::{
+    IdentityPublicKeyInCreationV0Getters, IdentityPublicKeyInCreationV0Setters,
+};
+use dpp::state_transition::public_key_in_creation::v0::IdentityPublicKeyInCreationV0;
+use pshenmic_dpp_enums::keys::key_type::KeyTypeWASM;
+use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
+use pshenmic_dpp_enums::keys::security_level::SecurityLevelWASM;
+use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "IdentityPublicKeyInCreationWASM")]
+pub struct IdentityPublicKeyInCreationWASM(IdentityPublicKeyInCreation);
+
+impl From<IdentityPublicKeyInCreation> for IdentityPublicKeyInCreationWASM {
+    fn from(value: IdentityPublicKeyInCreation) -> Self {
+        IdentityPublicKeyInCreationWASM(value)
+    }
+}
+
+impl From<IdentityPublicKeyInCreationWASM> for IdentityPublicKeyInCreation {
+    fn from(value: IdentityPublicKeyInCreationWASM) -> Self {
+        value.0
+    }
+}
+
+impl From<IdentityPublicKeyInCreationWASM> for IdentityPublicKey {
+    fn from(value: IdentityPublicKeyInCreationWASM) -> Self {
+        let contract_bounds = match value.0.contract_bounds() {
+            None => None,
+            Some(bounds) => Some(bounds.clone()),
+        };
+
+        IdentityPublicKey::V0(IdentityPublicKeyV0 {
+            id: value.0.id(),
+            purpose: value.0.purpose(),
+            security_level: value.0.security_level(),
+            contract_bounds,
+            key_type: value.0.key_type(),
+            read_only: value.0.read_only(),
+            data: value.0.data().clone(),
+            disabled_at: None,
+        })
+    }
+}
+
+#[wasm_bindgen]
+impl IdentityPublicKeyInCreationWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        id: u32,
+        purpose: PurposeWASM,
+        security_level: SecurityLevelWASM,
+        key_type: KeyTypeWASM,
+        read_only: bool,
+        binary_data: &str,
+        signature: &str,
+    ) -> IdentityPublicKeyInCreationWASM {
+        IdentityPublicKeyInCreationWASM(IdentityPublicKeyInCreation::V0(
+            IdentityPublicKeyInCreationV0 {
+                id,
+                key_type: KeyType::from(key_type),
+                purpose: Purpose::from(purpose),
+                security_level: SecurityLevel::from(security_level),
+                contract_bounds: None,
+                read_only,
+                data: BinaryData::from_string(binary_data, Hex).unwrap(),
+                signature: BinaryData::from_string(signature, Hex).unwrap(),
+            },
+        ))
+    }
+
+    #[wasm_bindgen(js_name = toIdentityPublicKey)]
+    pub fn to_identity_public_key(&self) -> IdentityPublicKeyWASM {
+        IdentityPublicKeyWASM::new(
+            self.0.id(),
+            self.0.purpose().into(),
+            self.0.security_level().into(),
+            self.0.key_type().into(),
+            self.0.read_only(),
+            self.0.data().to_string(Hex).as_str(),
+            None,
+        )
+    }
+
+    #[wasm_bindgen(js_name = getKeyId)]
+    pub fn get_key_id(&self) -> u32 {
+        self.0.id()
+    }
+
+    #[wasm_bindgen(js_name = getPurpose)]
+    pub fn get_purpose(&self) -> PurposeWASM {
+        PurposeWASM::from(self.0.purpose())
+    }
+
+    #[wasm_bindgen(js_name = getSecurityLevel)]
+    pub fn get_security_level(&self) -> SecurityLevelWASM {
+        SecurityLevelWASM::from(self.0.security_level())
+    }
+
+    #[wasm_bindgen(js_name = getKeyType)]
+    pub fn get_key_type(&self) -> KeyTypeWASM {
+        KeyTypeWASM::from(self.0.key_type())
+    }
+
+    #[wasm_bindgen(js_name = getReadOnly)]
+    pub fn get_read_only(&self) -> bool {
+        self.0.read_only()
+    }
+
+    #[wasm_bindgen(js_name = getData)]
+    pub fn get_data(&self) -> String {
+        self.0.data().to_string(Hex)
+    }
+
+    #[wasm_bindgen(js_name = setKeyId)]
+    pub fn set_key_id(&mut self, key_id: u32) {
+        self.0.set_id(key_id)
+    }
+
+    #[wasm_bindgen(js_name = setPurpose)]
+    pub fn set_purpose(&mut self, purpose: PurposeWASM) {
+        self.0.set_purpose(Purpose::from(purpose))
+    }
+
+    #[wasm_bindgen(js_name = setSecurityLevel)]
+    pub fn set_security_level(&mut self, security_level: SecurityLevelWASM) {
+        self.0
+            .set_security_level(SecurityLevel::from(security_level))
+    }
+
+    #[wasm_bindgen(js_name = setReadOnly)]
+    pub fn set_read_only(&mut self, read_only: bool) {
+        self.0.set_read_only(read_only)
+    }
+
+    #[wasm_bindgen(js_name = setData)]
+    pub fn set_data(&mut self, binary_data: &str) {
+        let data = BinaryData::from_string(binary_data, Hex).unwrap();
+        self.0.set_data(data)
+    }
+}

package/packages/identity_transitions/src/lib.rs

@@ -0,0 +1 @@
+mod create_transition;

package/packages/mock_bls/Cargo.toml

@@ -9,4 +9,8 @@ crate-type = ["cdylib", "lib"]
 [dependencies]
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "bls-signatures",
-]}
+]}
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/private_key/Cargo.toml

@@ -10,4 +10,8 @@ crate-type = ["cdylib", "lib"]
 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",
-]}
+]}
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/private_key/src/lib.rs

@@ -1,28 +1,20 @@
 use dpp::dashcore::PrivateKey;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name = "PrivateKeyWASM")]
-pub struct PrivateKeyWASM {
-    private_key: PrivateKey,
-}
+pub struct PrivateKeyWASM(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");
+    pub fn new(wif: &str) -> Result<Self, JsValue> {
+        let pk = PrivateKey::from_wif(wif).map_err(|err| JsValue::from_str(&*err.to_string()));
 
-        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()
+        match pk {
+            Ok(pk) => Ok(PrivateKeyWASM(pk)),
+            Err(err) => Err(err),
+        }
     }
 }
 
@@ -30,6 +22,11 @@ impl PrivateKeyWASM {
 impl PrivateKeyWASM {
     #[wasm_bindgen(js_name = "getKeyWIF")]
     pub fn get_key_wif(&self) -> String {
-        self.private_key.to_wif()
+        self.0.to_wif()
+    }
+
+    #[wasm_bindgen(js_name = "getKeyBytes")]
+    pub fn get_key_bytes(&self) -> Vec<u8> {
+        self.0.to_bytes()
     }
 }

package/packages/public_key/Cargo.toml

@@ -8,8 +8,12 @@ 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 = [
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "identity-value-conversion",
 ]}
-pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_utils = {path = "../utils"}
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/public_key/src/lib.rs

@@ -5,47 +5,52 @@ use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
 use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel, TimestampMillis};
 use dpp::platform_value::BinaryData;
 use dpp::platform_value::string_encoding::Encoding::Hex;
-use js_sys::Boolean;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
 use pshenmic_dpp_enums::keys::key_type::KeyTypeWASM;
 use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
 use pshenmic_dpp_enums::keys::security_level::SecurityLevelWASM;
+use pshenmic_dpp_utils::WithJsError;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
+#[derive(Clone)]
 #[wasm_bindgen(js_name = IdentityPublicKeyWASM)]
-pub struct IdentityPublicKeyWASM {
-    public_key: IdentityPublicKey,
+pub struct IdentityPublicKeyWASM(IdentityPublicKey);
+
+impl From<IdentityPublicKey> for IdentityPublicKeyWASM {
+    fn from(value: IdentityPublicKey) -> Self {
+        IdentityPublicKeyWASM(value)
+    }
+}
+
+impl From<IdentityPublicKeyWASM> for IdentityPublicKey {
+    fn from(value: IdentityPublicKeyWASM) -> Self {
+        value.0
+    }
 }
 
 #[wasm_bindgen]
 impl IdentityPublicKeyWASM {
-    #[wasm_bindgen]
+    #[wasm_bindgen(constructor)]
     pub fn new(
         id: u32,
         purpose: PurposeWASM,
         security_level: SecurityLevelWASM,
         key_type: KeyTypeWASM,
-        read_only: Boolean,
+        read_only: bool,
         binary_data: &str,
         disabled_at: Option<TimestampMillis>,
     ) -> Self {
-        IdentityPublicKeyWASM {
-            public_key: IdentityPublicKey::from(IdentityPublicKeyV0 {
-                id,
-                purpose: Purpose::from(purpose),
-                security_level: SecurityLevel::from(security_level),
-                contract_bounds: None,
-                key_type: KeyType::from(key_type),
-                read_only: read_only.as_bool().unwrap(),
-                data: BinaryData::from_string(binary_data, Hex).unwrap(),
-                disabled_at,
-            }),
-        }
-    }
-}
-
-impl IdentityPublicKeyWASM {
-    pub fn get_key(&self) -> IdentityPublicKey {
-        self.public_key.clone()
+        IdentityPublicKeyWASM(IdentityPublicKey::from(IdentityPublicKeyV0 {
+            id,
+            purpose: Purpose::from(purpose),
+            security_level: SecurityLevel::from(security_level),
+            contract_bounds: None,
+            key_type: KeyType::from(key_type),
+            read_only: read_only,
+            data: BinaryData::from_string(binary_data, Hex).unwrap(),
+            disabled_at,
+        }))
     }
 }
 
@@ -53,73 +58,88 @@ impl IdentityPublicKeyWASM {
 impl IdentityPublicKeyWASM {
     #[wasm_bindgen(js_name = getKeyId)]
     pub fn get_key_id(&self) -> u32 {
-        self.public_key.id()
+        self.0.id()
     }
 
     #[wasm_bindgen(js_name = getPurpose)]
     pub fn get_purpose(&self) -> PurposeWASM {
-        PurposeWASM::from(self.public_key.purpose())
+        PurposeWASM::from(self.0.purpose())
     }
 
     #[wasm_bindgen(js_name = getSecurityLevel)]
     pub fn get_security_level(&self) -> SecurityLevelWASM {
-        SecurityLevelWASM::from(self.public_key.security_level())
+        SecurityLevelWASM::from(self.0.security_level())
     }
 
     #[wasm_bindgen(js_name = getKeyType)]
     pub fn get_key_type(&self) -> KeyTypeWASM {
-        KeyTypeWASM::from(self.public_key.key_type())
+        KeyTypeWASM::from(self.0.key_type())
     }
 
     #[wasm_bindgen(js_name = getReadOnly)]
     pub fn get_read_only(&self) -> bool {
-        self.public_key.read_only()
+        self.0.read_only()
     }
 
     #[wasm_bindgen(js_name = getData)]
     pub fn get_data(&self) -> String {
-        self.public_key.data().to_string(Hex)
+        self.0.data().to_string(Hex)
     }
 
     #[wasm_bindgen(js_name = getDisabledAt)]
     pub fn get_disabled_at(&self) -> Option<u64> {
-        self.public_key.disabled_at()
+        self.0.disabled_at()
     }
 
     #[wasm_bindgen(js_name = setKeyId)]
     pub fn set_key_id(&mut self, key_id: u32) {
-        self.public_key.set_id(key_id)
+        self.0.set_id(key_id)
     }
 
     #[wasm_bindgen(js_name = setPurpose)]
     pub fn set_purpose(&mut self, purpose: PurposeWASM) {
-        self.public_key.set_purpose(Purpose::from(purpose))
+        self.0.set_purpose(Purpose::from(purpose))
     }
 
     #[wasm_bindgen(js_name = setSecurityLevel)]
     pub fn set_security_level(&mut self, security_level: SecurityLevelWASM) {
-        self.public_key
+        self.0
             .set_security_level(SecurityLevel::from(security_level))
     }
 
     #[wasm_bindgen(js_name = setKeyType)]
     pub fn set_key_type(&mut self, key_type: KeyTypeWASM) {
-        self.public_key.set_key_type(KeyType::from(key_type))
+        self.0.set_key_type(KeyType::from(key_type))
     }
 
     #[wasm_bindgen(js_name = setReadOnly)]
-    pub fn set_read_only(&mut self, read_only: Boolean) {
-        self.public_key.set_read_only(read_only.as_bool().unwrap())
+    pub fn set_read_only(&mut self, read_only: bool) {
+        self.0.set_read_only(read_only)
     }
 
     #[wasm_bindgen(js_name = setData)]
     pub fn set_data(&mut self, binary_data: &str) {
         let data = BinaryData::from_string(binary_data, Hex).unwrap();
-        self.public_key.set_data(data)
+        self.0.set_data(data)
     }
 
     #[wasm_bindgen(js_name = setDisabledAt)]
     pub fn set_disabled_at(&mut self, disabled_at: u64) {
-        self.public_key.set_disabled_at(disabled_at)
+        self.0.set_disabled_at(disabled_at)
+    }
+
+    #[wasm_bindgen(js_name = toBuffer)]
+    pub fn to_buffer(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = fromBuffer)]
+    pub fn from_buffer(buffer: Vec<u8>) -> Result<IdentityPublicKeyWASM, JsValue> {
+        let rs_pk = IdentityPublicKey::deserialize_from_bytes(buffer.as_slice()).with_js_error();
+
+        match rs_pk {
+            Ok(pk) => Ok(IdentityPublicKeyWASM(pk)),
+            Err(e) => Err(e),
+        }
     }
 }

package/packages/state_transition/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "pshenmic_dpp_state_transition"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+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"}
+pshenmic_dpp_enums = {path = "../enums"}
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "state-transition-signing"
+]}
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/state_transition/src/lib.rs

@@ -0,0 +1,95 @@
+use dpp::identity::KeyType;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::state_transition::StateTransition;
+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 wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "StateTransitionWASM")]
+pub struct StateTransitionWASM(StateTransition);
+
+impl From<StateTransition> for StateTransitionWASM {
+    fn from(transition: StateTransition) -> Self {
+        StateTransitionWASM(transition)
+    }
+}
+
+impl From<StateTransitionWASM> for StateTransition {
+    fn from(transition: StateTransitionWASM) -> Self {
+        transition.0
+    }
+}
+
+#[wasm_bindgen]
+impl StateTransitionWASM {
+    #[wasm_bindgen(js_name=sign)]
+    pub fn sign(
+        &mut self,
+        private_key: PrivateKeyWASM,
+        public_key: IdentityPublicKeyWASM,
+    ) -> Result<JsValue, JsValue> {
+        let sig = self.0.sign(
+            &public_key.into(),
+            private_key.get_key_bytes().as_slice(),
+            &MockBLS {},
+        );
+
+        let bytes = match sig {
+            Ok(_sig) => {
+                self.0.set_signature(self.0.signature().clone());
+                self.0
+                    .set_signature_public_key_id(self.0.signature_public_key_id().unwrap());
+                self.0.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 _sig = self
+            .0
+            .sign_by_private_key(
+                &private_key.get_key_bytes().as_slice(),
+                KeyType::from(key_type),
+                &MockBLS {},
+            )
+            .with_js_error();
+
+        let bytes = self.0.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 = self.0.serialize_to_bytes().expect("Serialization failed");
+
+        Ok(JsValue::from(bytes.clone()))
+    }
+
+    pub fn from_buffer(buffer: Vec<u8>) -> Result<StateTransitionWASM, JsValue> {
+        let st = StateTransition::deserialize_from_bytes(buffer.as_slice());
+
+        match st {
+            Err(err) => Err(JsValue::from_str(err.to_string().as_str())),
+            Ok(transition) => Ok(StateTransitionWASM(transition)),
+        }
+    }
+}

package/packages/utils/Cargo.toml

@@ -18,3 +18,7 @@ serde_json = { version = "1.0", features = ["preserve_order"] }
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
 serde = { version = "1.0.197", features = ["derive"] }
 itertools = { version = "0.13" }
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/scripts/build.sh

@@ -4,9 +4,8 @@
 TARGET=wasm32-unknown-unknown
 
 OUTPUT_DIR="${PWD}/wasm"
-CARGO_BUILD_PROFILE="${CARGO_BUILD_PROFILE:-dev}"
-PROFILE_ARG="--profile ${CARGO_BUILD_PROFILE}"
-PROFILE=debug
+PROFILE_ARG="--release"
+PROFILE=release
 
 OUTPUT_FILE="${PWD}/wasm/pshenmic_dpp_bg.wasm"
 

package/src/lib.rs

@@ -1,2 +1,5 @@
 pub use pshenmic_dpp_document_batch::DocumentBatchWASM;
 pub use pshenmic_dpp_document_search;
+pub use pshenmic_dpp_identity;
+pub use pshenmic_dpp_identity_transitions;
+pub use pshenmic_dpp_state_transition;