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

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

@@ -0,0 +1,278 @@
+use crate::utils::ToSerdeJSONExt;
+
+use std::convert::TryInto;
+use std::default::Default;
+
+use wasm_bindgen::prelude::*;
+
+use crate::identifier::IdentifierWrapper;
+
+use crate::{
+    buffer::Buffer,
+    create_asset_lock_proof_from_wasm_instance,
+    errors::RustConversionError,
+    identity::state_transition::asset_lock_proof::{
+        ChainAssetLockProofWasm, InstantAssetLockProofWasm,
+    },
+    state_transition::StateTransitionExecutionContextWasm,
+    with_js_error,
+};
+
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+
+use dpp::{
+    identifier::Identifier,
+    identity::state_transition::{
+        asset_lock_proof::AssetLockProof, identity_topup_transition::IdentityTopUpTransition,
+    },
+    state_transition::StateTransitionLike,
+    util::string_encoding,
+    util::string_encoding::Encoding,
+};
+
+#[wasm_bindgen(js_name=IdentityTopUpTransition)]
+#[derive(Clone)]
+pub struct IdentityTopUpTransitionWasm(IdentityTopUpTransition);
+
+impl From<IdentityTopUpTransition> for IdentityTopUpTransitionWasm {
+    fn from(v: IdentityTopUpTransition) -> Self {
+        IdentityTopUpTransitionWasm(v)
+    }
+}
+
+impl From<IdentityTopUpTransitionWasm> for IdentityTopUpTransition {
+    fn from(v: IdentityTopUpTransitionWasm) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen(js_class = IdentityTopUpTransition)]
+impl IdentityTopUpTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<IdentityTopUpTransitionWasm, JsValue> {
+        let raw_state_transition = raw_parameters.with_serde_to_json_value()?;
+
+        let identity_topup_transition =
+            IdentityTopUpTransition::from_raw_object(raw_state_transition)
+                .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
+
+        Ok(identity_topup_transition.into())
+    }
+
+    #[wasm_bindgen(js_name=setAssetLockProof)]
+    pub fn set_asset_lock_proof(&mut self, asset_lock_proof: JsValue) -> Result<(), JsValue> {
+        let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?;
+
+        self.0
+            .set_asset_lock_proof(asset_lock_proof)
+            .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(getter, js_name=assetLockProof)]
+    pub fn asset_lock_proof(&self) -> JsValue {
+        self.get_asset_lock_proof()
+    }
+
+    #[wasm_bindgen(js_name=getAssetLockProof)]
+    pub fn get_asset_lock_proof(&self) -> JsValue {
+        let asset_lock_proof = self.0.get_asset_lock_proof().to_owned();
+
+        match asset_lock_proof {
+            AssetLockProof::Chain(chain_asset_lock_proof) => {
+                ChainAssetLockProofWasm::from(chain_asset_lock_proof).into()
+            }
+            AssetLockProof::Instant(instant_asset_lock_proof) => {
+                InstantAssetLockProofWasm::from(instant_asset_lock_proof).into()
+            }
+        }
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        self.0.get_type() as u8
+    }
+
+    #[wasm_bindgen(getter, js_name=identityId)]
+    pub fn identity_id(&self) -> IdentifierWrapper {
+        self.get_identity_id()
+    }
+
+    #[wasm_bindgen(js_name=getIdentityId)]
+    pub fn get_identity_id(&self) -> IdentifierWrapper {
+        (*self.0.get_identity_id()).into()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        (*self.0.get_owner_id()).into()
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
+        let opts: super::to_object::ToObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let object = super::to_object::to_object_struct(&self.0, opts);
+        let js_object = js_sys::Object::new();
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"type".to_owned().into(),
+            &object.transition_type.into(),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"protocolVersion".to_owned().into(),
+            &object.protocol_version.into(),
+        )?;
+
+        if let Some(signature) = object.signature {
+            let signature_value: JsValue = if signature.is_empty() {
+                JsValue::undefined()
+            } else {
+                Buffer::from_bytes(signature.as_slice()).into()
+            };
+
+            js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?;
+        }
+
+        let asset_lock_proof_object = match object.asset_lock_proof {
+            AssetLockProof::Instant(instant_asset_lock_proof) => {
+                InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_object()?
+            }
+            AssetLockProof::Chain(chain_asset_lock_proof) => {
+                ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_object()?
+            }
+        };
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"assetLockProof".to_owned().into(),
+            &asset_lock_proof_object,
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"identityId".to_owned().into(),
+            &Buffer::from_bytes(object.identity_id.buffer.as_slice()),
+        )?;
+
+        Ok(js_object.into())
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let object = super::to_object::to_object_struct(&self.0, Default::default());
+        let js_object = js_sys::Object::new();
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"type".to_owned().into(),
+            &object.transition_type.into(),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"protocolVersion".to_owned().into(),
+            &object.protocol_version.into(),
+        )?;
+
+        if let Some(signature) = object.signature {
+            let signature_value: JsValue = if signature.is_empty() {
+                JsValue::undefined()
+            } else {
+                string_encoding::encode(signature.as_slice(), Encoding::Base64).into()
+            };
+
+            js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?;
+        }
+
+        let asset_lock_proof_json = match object.asset_lock_proof {
+            AssetLockProof::Instant(instant_asset_lock_proof) => {
+                InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_json()?
+            }
+            AssetLockProof::Chain(chain_asset_lock_proof) => {
+                ChainAssetLockProofWasm::from(chain_asset_lock_proof).to_json()?
+            }
+        };
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"assetLockProof".to_owned().into(),
+            &asset_lock_proof_json,
+        )?;
+
+        let identity_id = object.identity_id.to_string(Encoding::Base58);
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"identityId".to_owned().into(),
+            &identity_id.into(),
+        )?;
+
+        Ok(js_object.into())
+    }
+
+    #[wasm_bindgen(js_name=getModifiedDataIds)]
+    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
+        let ids = self.0.get_modified_data_ids();
+
+        ids.into_iter()
+            .map(|id| <IdentifierWrapper as std::convert::From<Identifier>>::from(id).into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=isDataContractStateTransition)]
+    pub fn is_data_contract_state_transition(&self) -> bool {
+        self.0.is_data_contract_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isDocumentStateTransition)]
+    pub fn is_document_state_transition(&self) -> bool {
+        self.0.is_document_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isIdentityStateTransition)]
+    pub fn is_identity_state_transition(&self) -> bool {
+        self.0.is_identity_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=setExecutionContext)]
+    pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) {
+        self.0.set_execution_context(context.into())
+    }
+
+    #[wasm_bindgen(js_name=getExecutionContext)]
+    pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm {
+        self.0.get_execution_context().into()
+    }
+
+    #[wasm_bindgen(js_name=signByPrivateKey)]
+    pub fn sign_by_private_key(
+        &mut self,
+        private_key: Vec<u8>,
+        key_type: u8,
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        let bls_adapter = BlsAdapter(bls);
+        let key_type = key_type
+            .try_into()
+            .map_err(|e: anyhow::Error| e.to_string())?;
+
+        self.0
+            .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=getSignature)]
+    pub fn get_signature(&self) -> Buffer {
+        Buffer::from_bytes(self.0.get_signature().as_slice())
+    }
+}

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

@@ -0,0 +1,113 @@
+use dpp::identity::state_transition::asset_lock_proof::{
+    AssetLockProofValidator, AssetLockTransactionValidator, ChainAssetLockProofStructureValidator,
+    InstantAssetLockProofStructureValidator,
+};
+use dpp::identity::state_transition::identity_topup_transition::validation::basic::IdentityTopUpTransitionBasicValidator;
+
+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::errors::from_dpp_err;
+use crate::utils::ToSerdeJSONExt;
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation::ValidationResultWasm,
+    StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name=IdentityTopUpTransitionBasicValidator)]
+pub struct IdentityTopUpTransitionBasicValidatorWasm(
+    IdentityTopUpTransitionBasicValidator<ExternalStateRepositoryLikeWrapper>,
+);
+
+impl From<IdentityTopUpTransitionBasicValidator<ExternalStateRepositoryLikeWrapper>>
+    for IdentityTopUpTransitionBasicValidatorWasm
+{
+    fn from(
+        validator: IdentityTopUpTransitionBasicValidator<ExternalStateRepositoryLikeWrapper>,
+    ) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityTopUpTransitionBasicValidator)]
+impl IdentityTopUpTransitionBasicValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> Result<IdentityTopUpTransitionBasicValidatorWasm, 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 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 validator = IdentityTopUpTransitionBasicValidator::new(
+            protocol_version_validator,
+            Arc::new(asset_lock_proof_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_topup_transition/identity_topup_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::IdentityTopUpTransitionWasm;
+use dpp::identity::state_transition::identity_topup_transition::validation::state::validate_identity_topup_transition_state;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=IdentityTopUpTransitionStateValidator)]
+pub struct IdentityTopUpTransitionStateValidator {
+    state_repository: ExternalStateRepositoryLikeWrapper,
+}
+
+#[wasm_bindgen(js_class=IdentityTopUpTransitionStateValidator)]
+impl IdentityTopUpTransitionStateValidator {
+    #[wasm_bindgen(constructor)]
+    pub fn new(state_repository: ExternalStateRepositoryLike) -> Self {
+        Self {
+            state_repository: ExternalStateRepositoryLikeWrapper::new(state_repository),
+        }
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        state_transition: &IdentityTopUpTransitionWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let validation_result = validate_identity_topup_transition_state(
+            &state_transition.to_owned().into(),
+            &self.state_repository,
+        )
+        .await
+        .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}

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

@@ -0,0 +1,8 @@
+pub use identity_topup_transition::*;
+
+pub mod apply_identity_topup_transition;
+pub mod identity_topup_transition;
+pub mod identity_topup_transition_basic_validator;
+pub mod identity_topup_transition_state_validator;
+
+mod to_object;

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

@@ -0,0 +1,42 @@
+use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
+use dpp::{
+    identifier::Identifier,
+    identity::state_transition::identity_topup_transition::IdentityTopUpTransition,
+    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 signature: Option<Vec<u8>>,
+}
+
+pub fn to_object_struct(
+    transition: &IdentityTopUpTransition,
+    options: ToObjectOptions,
+) -> ToObject {
+    let mut to_object = ToObject {
+        transition_type: transition.get_type() as u8,
+        protocol_version: transition.get_protocol_version(),
+        identity_id: *transition.get_identity_id(),
+        asset_lock_proof: transition.get_asset_lock_proof().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_update_transition/apply_identity_update_transition.rs

@@ -0,0 +1,24 @@
+use dpp::identity::state_transition::identity_update_transition::apply_identity_update_transition::apply_identity_update_transition;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    IdentityUpdateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=applyIdentityUpdateTransition)]
+pub async fn apply_identity_update_transition_wasm(
+    state_repository: ExternalStateRepositoryLike,
+    state_transition: &IdentityUpdateTransitionWasm,
+) -> Result<(), JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+
+    apply_identity_update_transition(
+        &wrapped_state_repository,
+        state_transition.to_owned().into(),
+    )
+    .await
+    .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+    Ok(())
+}

package/src/identity/state_transition/identity_update_transition/identity_update_public_keys_validator.rs

@@ -0,0 +1,55 @@
+use crate::errors::from_dpp_err;
+use crate::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransitionWasm;
+use crate::validation::ValidationResultWasm;
+use dpp::document::document_transition::document_base_transition::JsonValue;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransition;
+use dpp::identity::state_transition::identity_update_transition::validate_public_keys::IdentityUpdatePublicKeysValidator;
+use dpp::identity::validation::TPublicKeysValidator;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=IdentityUpdatePublicKeysValidator)]
+pub struct IdentityUpdatePublicKeysValidatorWasm(IdentityUpdatePublicKeysValidator);
+
+impl From<IdentityUpdatePublicKeysValidator> for IdentityUpdatePublicKeysValidatorWasm {
+    fn from(v: IdentityUpdatePublicKeysValidator) -> Self {
+        Self(v)
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityUpdatePublicKeysValidator)]
+impl IdentityUpdatePublicKeysValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> IdentityUpdatePublicKeysValidatorWasm {
+        let validator = IdentityUpdatePublicKeysValidator {};
+        validator.into()
+    }
+
+    #[wasm_bindgen]
+    pub fn validate(&self, raw_public_keys: Vec<JsValue>) -> Result<ValidationResultWasm, JsValue> {
+        let public_keys = raw_public_keys
+            .into_iter()
+            .map(|raw_key| {
+                let parsed_key: IdentityPublicKeyCreateTransition =
+                    IdentityPublicKeyCreateTransitionWasm::new(raw_key)?.into();
+
+                parsed_key
+                    .to_raw_json_object(false)
+                    .map_err(|e| from_dpp_err(e.into()))
+            })
+            .collect::<Result<Vec<JsonValue>, JsValue>>()?;
+
+        let result = self
+            .0
+            .validate_keys(&public_keys)
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(result.map(|_| JsValue::undefined()).into())
+    }
+}
+
+impl Default for IdentityUpdatePublicKeysValidatorWasm {
+    fn default() -> Self {
+        Self::new()
+    }
+}