@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.14

package/src/identity/state_transition/identity_create_transition/identity_create_transition_basic_validator.rs

@@ -0,0 +1,153 @@
+use dpp::identity::state_transition::asset_lock_proof::{
+    AssetLockProofValidator, AssetLockTransactionValidator, ChainAssetLockProofStructureValidator,
+    InstantAssetLockProofStructureValidator,
+};
+use dpp::identity::state_transition::identity_create_transition::validation::basic::IdentityCreateTransitionBasicValidator;
+use dpp::identity::state_transition::validate_public_key_signatures::PublicKeysSignaturesValidator;
+use dpp::identity::validation::{
+    PublicKeysValidator, RequiredPurposeAndSecurityLevelValidator, PUBLIC_KEY_SCHEMA_FOR_TRANSITION,
+};
+use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
+
+use dpp::version::{ProtocolVersionValidator, COMPATIBILITY_MAP, LATEST_VERSION};
+use dpp::ProtocolError;
+
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+use crate::utils::ToSerdeJSONExt;
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation::ValidationResultWasm,
+    StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name=IdentityCreateTransitionBasicValidator)]
+pub struct IdentityCreateTransitionBasicValidatorWasm(
+    IdentityCreateTransitionBasicValidator<
+        PublicKeysValidator<BlsAdapter>,
+        RequiredPurposeAndSecurityLevelValidator,
+        ExternalStateRepositoryLikeWrapper,
+        PublicKeysSignaturesValidator<BlsAdapter>,
+        BlsAdapter,
+    >,
+);
+
+impl
+    From<
+        IdentityCreateTransitionBasicValidator<
+            PublicKeysValidator<BlsAdapter>,
+            RequiredPurposeAndSecurityLevelValidator,
+            ExternalStateRepositoryLikeWrapper,
+            PublicKeysSignaturesValidator<BlsAdapter>,
+            BlsAdapter,
+        >,
+    > for IdentityCreateTransitionBasicValidatorWasm
+{
+    fn from(
+        validator: IdentityCreateTransitionBasicValidator<
+            PublicKeysValidator<BlsAdapter>,
+            RequiredPurposeAndSecurityLevelValidator,
+            ExternalStateRepositoryLikeWrapper,
+            PublicKeysSignaturesValidator<BlsAdapter>,
+            BlsAdapter,
+        >,
+    ) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityCreateTransitionBasicValidator)]
+impl IdentityCreateTransitionBasicValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+        js_bls: JsBlsAdapter,
+    ) -> Result<IdentityCreateTransitionBasicValidatorWasm, JsValue> {
+        let state_repository_wrapper =
+            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+        let protocol_version_validator = ProtocolVersionValidator::new(
+            LATEST_VERSION,
+            LATEST_VERSION,
+            COMPATIBILITY_MAP.clone(),
+        );
+
+        let public_keys_validator = PublicKeysValidator::new_with_schema(
+            PUBLIC_KEY_SCHEMA_FOR_TRANSITION.clone(),
+            BlsAdapter(js_bls.clone()),
+        )
+        .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+        let public_keys_transition_validator = RequiredPurposeAndSecurityLevelValidator::default();
+
+        let asset_lock_proof_validator: AssetLockProofValidator<
+            ExternalStateRepositoryLikeWrapper,
+        >;
+        {
+            let tx_validator = Arc::new(AssetLockTransactionValidator::new(
+                state_repository_wrapper.clone(),
+            ));
+
+            let instant_asset_lock_proof_validator = InstantAssetLockProofStructureValidator::new(
+                state_repository_wrapper.clone(),
+                tx_validator.clone(),
+            )
+            .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+            let chain_asset_lock_proof_validator =
+                ChainAssetLockProofStructureValidator::new(state_repository_wrapper, tx_validator)
+                    .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+            asset_lock_proof_validator = AssetLockProofValidator::new(
+                instant_asset_lock_proof_validator,
+                chain_asset_lock_proof_validator,
+            );
+        }
+
+        let public_keys_signature_validator =
+            PublicKeysSignaturesValidator::new(BlsAdapter(js_bls.clone()));
+
+        let validator = IdentityCreateTransitionBasicValidator::new(
+            protocol_version_validator,
+            Arc::new(public_keys_validator),
+            Arc::new(public_keys_transition_validator),
+            Arc::new(asset_lock_proof_validator),
+            BlsAdapter(js_bls),
+            Arc::new(public_keys_signature_validator),
+        )
+        .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+        Ok(validator.into())
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        mut self,
+        raw_state_transition: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let execution_context: &StateTransitionExecutionContext = execution_context.into();
+
+        let current_protocol_version =
+            js_sys::Reflect::get(&raw_state_transition, &"protocolVersion".into())
+                .map(|v| v.as_f64().unwrap_or(LATEST_VERSION as f64) as u32)
+                .unwrap_or(LATEST_VERSION);
+
+        self.0
+            .protocol_version_validator()
+            .set_current_protocol_version(current_protocol_version);
+
+        let state_transition_json = raw_state_transition.with_serde_to_json_value()?;
+
+        let validation_result = self
+            .0
+            .validate(&state_transition_json, execution_context)
+            .await
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity/state_transition/identity_create_transition/identity_create_transition_state_validator.rs

@@ -0,0 +1,37 @@
+use crate::errors::from_dpp_err;
+use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
+use crate::validation::ValidationResultWasm;
+use crate::IdentityCreateTransitionWasm;
+use dpp::identity::state_transition::identity_create_transition::validation::state::validate_identity_create_transition_state;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=IdentityCreateTransitionStateValidator)]
+pub struct IdentityCreateTransitionStateValidator {
+    state_repository: ExternalStateRepositoryLikeWrapper,
+}
+
+#[wasm_bindgen(js_class=IdentityCreateTransitionStateValidator)]
+impl IdentityCreateTransitionStateValidator {
+    #[wasm_bindgen(constructor)]
+    pub fn new(state_repository: ExternalStateRepositoryLike) -> Self {
+        Self {
+            state_repository: ExternalStateRepositoryLikeWrapper::new(state_repository),
+        }
+    }
+
+    #[wasm_bindgen(js_name = validate)]
+    pub async fn validate(
+        &self,
+        state_transition: &IdentityCreateTransitionWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let validation_result = validate_identity_create_transition_state(
+            &self.state_repository,
+            &state_transition.to_owned().into(),
+        )
+        .await
+        .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity/state_transition/identity_create_transition/mod.rs

@@ -0,0 +1,8 @@
+pub use identity_create_transition::*;
+
+pub mod apply_identity_create_transition;
+pub mod identity_create_transition;
+pub mod identity_create_transition_basic_validator;
+pub mod identity_create_transition_state_validator;
+
+mod to_object;

package/src/identity/state_transition/identity_create_transition/to_object.rs

@@ -0,0 +1,45 @@
+use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransition;
+use dpp::{
+    identifier::Identifier,
+    identity::state_transition::identity_create_transition::IdentityCreateTransition,
+    state_transition::StateTransitionLike,
+};
+use serde::Deserialize;
+use std::default::Default;
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct ToObjectOptions {
+    pub skip_signature: Option<bool>,
+}
+
+#[derive(Default)]
+pub struct ToObject {
+    pub transition_type: u8,
+    pub protocol_version: u32,
+    pub identity_id: Identifier,
+    pub asset_lock_proof: AssetLockProof,
+    pub public_keys: Vec<IdentityPublicKeyCreateTransition>,
+    pub signature: Option<Vec<u8>>,
+}
+
+pub fn to_object_struct(
+    transition: &IdentityCreateTransition,
+    options: ToObjectOptions,
+) -> ToObject {
+    let mut to_object = ToObject {
+        transition_type: transition.get_type() as u8,
+        protocol_version: transition.get_protocol_version(),
+        public_keys: transition.get_public_keys().to_owned(),
+        asset_lock_proof: transition.get_asset_lock_proof().to_owned(),
+        identity_id: transition.get_identity_id().to_owned(),
+        signature: None,
+    };
+
+    if !options.skip_signature.unwrap_or(false) {
+        to_object.signature = Some(transition.get_signature().to_owned());
+    }
+
+    to_object
+}

package/src/identity/state_transition/identity_public_key_transitions.rs

@@ -0,0 +1,207 @@
+//todo: move this file to transition
+use dpp::dashcore::anyhow;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransition;
+pub use serde::{Deserialize, Serialize};
+use std::convert::{TryFrom, TryInto};
+use wasm_bindgen::prelude::*;
+
+use crate::errors::from_dpp_err;
+use crate::{buffer::Buffer, utils, with_js_error};
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+struct ToObjectOptions {
+    pub skip_signature: Option<bool>,
+}
+
+#[wasm_bindgen(js_name=IdentityPublicKeyCreateTransition)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct IdentityPublicKeyCreateTransitionWasm(IdentityPublicKeyCreateTransition);
+
+#[wasm_bindgen(js_class = IdentityPublicKeyCreateTransition)]
+impl IdentityPublicKeyCreateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_public_key: JsValue) -> Result<IdentityPublicKeyCreateTransitionWasm, JsValue> {
+        let data_string = utils::stringify(&raw_public_key)?;
+        let pk: IdentityPublicKeyCreateTransitionWasm =
+            serde_json::from_str(&data_string).map_err(|e| e.to_string())?;
+
+        Ok(pk)
+    }
+
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> u32 {
+        self.0.id
+    }
+
+    #[wasm_bindgen(js_name=setId)]
+    pub fn set_id(&mut self, id: u32) {
+        self.0.id = id;
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        self.0.key_type as u8
+    }
+
+    #[wasm_bindgen(js_name=setType)]
+    pub fn set_type(&mut self, key_type: u8) -> Result<(), JsValue> {
+        self.0.key_type = key_type
+            .try_into()
+            .map_err(|e: anyhow::Error| e.to_string())?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=setData)]
+    pub fn set_data(&mut self, data: Vec<u8>) -> Result<(), JsValue> {
+        self.0.data = data;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getData)]
+    pub fn get_data(&self) -> Vec<u8> {
+        self.0.data.clone()
+    }
+
+    #[wasm_bindgen(js_name=setPurpose)]
+    pub fn set_purpose(&mut self, purpose: u8) -> Result<(), JsValue> {
+        self.0.purpose = purpose
+            .try_into()
+            .map_err(|e: anyhow::Error| e.to_string())?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getPurpose)]
+    pub fn get_purpose(&self) -> u8 {
+        self.0.purpose as u8
+    }
+
+    #[wasm_bindgen(js_name=setSecurityLevel)]
+    pub fn set_security_level(&mut self, security_level: u8) -> Result<(), JsValue> {
+        self.0.security_level = security_level
+            .try_into()
+            .map_err(|e: anyhow::Error| e.to_string())?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getSecurityLevel)]
+    pub fn get_security_level(&self) -> u8 {
+        self.0.security_level as u8
+    }
+
+    #[wasm_bindgen(js_name=setReadOnly)]
+    pub fn set_read_only(&mut self, read_only: bool) {
+        self.0.read_only = read_only;
+    }
+
+    #[wasm_bindgen(js_name=isReadOnly)]
+    pub fn is_read_only(&self) -> bool {
+        self.0.read_only
+    }
+
+    #[wasm_bindgen(js_name=setSignature)]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.signature = signature
+    }
+
+    #[wasm_bindgen(js_name=getSignature)]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature.clone()
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.hash().map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=isMaster)]
+    pub fn is_master(&self) -> bool {
+        self.0.is_master()
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let val = self.0.to_json().map_err(|e| from_dpp_err(e.into()))?;
+        let json = val.to_string();
+        js_sys::JSON::parse(&json)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
+        let opts: ToObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let val = self
+            .0
+            .to_raw_json_object(opts.skip_signature.unwrap_or(false))
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        let data_buffer = Buffer::from_bytes(self.0.data.as_slice());
+
+        let json = val.to_string();
+        let js_object = js_sys::JSON::parse(&json)?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &JsValue::from_str("type"),
+            &JsValue::from(self.get_type()),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &JsValue::from_str("data"),
+            &JsValue::from(data_buffer),
+        )?;
+
+        if !opts.skip_signature.unwrap_or(false) && !self.0.signature.is_empty() {
+            js_sys::Reflect::set(
+                &js_object,
+                &JsValue::from_str("signature"),
+                &JsValue::from(Buffer::from_bytes(&self.0.signature)),
+            )?;
+        }
+
+        Ok(js_object)
+    }
+}
+
+impl IdentityPublicKeyCreateTransitionWasm {
+    pub fn into_inner(self) -> IdentityPublicKeyCreateTransition {
+        self.0
+    }
+
+    pub fn inner(&self) -> &IdentityPublicKeyCreateTransition {
+        &self.0
+    }
+
+    pub fn inner_mut(&mut self) -> &mut IdentityPublicKeyCreateTransition {
+        &mut self.0
+    }
+}
+
+impl From<IdentityPublicKeyCreateTransition> for IdentityPublicKeyCreateTransitionWasm {
+    fn from(v: IdentityPublicKeyCreateTransition) -> Self {
+        IdentityPublicKeyCreateTransitionWasm(v)
+    }
+}
+
+impl TryFrom<JsValue> for IdentityPublicKeyCreateTransitionWasm {
+    type Error = JsValue;
+
+    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        let str = String::from(js_sys::JSON::stringify(&value)?);
+        let val = serde_json::from_str(&str).map_err(|e| from_dpp_err(e.into()))?;
+        Ok(Self(
+            IdentityPublicKeyCreateTransition::from_raw_object(val).map_err(from_dpp_err)?,
+        ))
+    }
+}
+
+impl From<IdentityPublicKeyCreateTransitionWasm> for IdentityPublicKeyCreateTransition {
+    fn from(pk: IdentityPublicKeyCreateTransitionWasm) -> Self {
+        pk.0
+    }
+}

package/src/identity/state_transition/identity_topup_transition/apply_identity_topup_transition.rs

@@ -0,0 +1,31 @@
+use dpp::identity::state_transition::asset_lock_proof::AssetLockTransactionOutputFetcher;
+use dpp::identity::state_transition::identity_topup_transition::ApplyIdentityTopUpTransition;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    IdentityTopUpTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=applyIdentityTopUpTransition)]
+pub async fn apply_identity_topup_transition_wasm(
+    state_repository: ExternalStateRepositoryLike,
+    state_transition: &IdentityTopUpTransitionWasm,
+) -> Result<(), JsValue> {
+    let wrapped_state_repository =
+        Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+    let tx_output_fetcher =
+        AssetLockTransactionOutputFetcher::new(wrapped_state_repository.clone());
+
+    let instance =
+        ApplyIdentityTopUpTransition::new(wrapped_state_repository, Arc::new(tx_output_fetcher));
+
+    instance
+        .apply(&state_transition.to_owned().into())
+        .await
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+    Ok(())
+}