@dashevo/wasm-dpp 0.24.0-dev.11 → 0.24.0-dev.13

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().clone(),
+        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/mod.rs

@@ -0,0 +1,9 @@
+pub use asset_lock_proof::*;
+pub use identity_create_transition::*;
+pub use identity_topup_transition::*;
+pub use validate_public_key_signatures::*;
+
+mod asset_lock_proof;
+mod identity_create_transition;
+mod identity_topup_transition;
+mod validate_public_key_signatures;

package/src/identity/state_transition/validate_public_key_signatures.rs

@@ -0,0 +1,59 @@
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+use crate::utils::ToSerdeJSONExt;
+
+use crate::{
+    identity::identity_public_key::IdentityPublicKeyWasm, validation::ValidationResultWasm,
+};
+
+use dpp::identity::state_transition::validate_public_key_signatures::{
+    PublicKeysSignaturesValidator, TPublicKeysSignaturesValidator,
+};
+use dpp::prelude::IdentityPublicKey;
+
+use serde_json::Value as JsonValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name = PublicKeysSignaturesValidator)]
+pub struct PublicKeysSignaturesValidatorWasm(PublicKeysSignaturesValidator<BlsAdapter>);
+
+impl From<PublicKeysSignaturesValidator<BlsAdapter>> for PublicKeysSignaturesValidatorWasm {
+    fn from(validator: PublicKeysSignaturesValidator<BlsAdapter>) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class = PublicKeysSignaturesValidator)]
+impl PublicKeysSignaturesValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(bls: JsBlsAdapter) -> PublicKeysSignaturesValidatorWasm {
+        PublicKeysSignaturesValidator::new(BlsAdapter(bls)).into()
+    }
+
+    #[wasm_bindgen(js_name=validate)]
+    pub fn validate_public_key_signatures(
+        &self,
+        raw_state_transition: JsValue,
+        raw_public_keys: Vec<JsValue>,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let state_transition_json = raw_state_transition.with_serde_to_json_value()?;
+
+        let public_keys = raw_public_keys
+            .into_iter()
+            .map(|raw_key| {
+                let parsed_key: IdentityPublicKey = IdentityPublicKeyWasm::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_public_key_signatures(&state_transition_json, &public_keys)
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity/validation/mod.rs

@@ -0,0 +1,3 @@
+mod public_keys_validator;
+
+pub use public_keys_validator::*;

package/src/identity/validation/public_keys_validator.rs

@@ -0,0 +1,76 @@
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+
+use crate::utils::{to_vec_of_serde_values, ToSerdeJSONExt};
+use crate::validation::ValidationResultWasm;
+use dpp::identity::validation::{
+    PublicKeysValidator, TPublicKeysValidator, PUBLIC_KEY_SCHEMA_FOR_TRANSITION,
+};
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = PublicKeysValidator)]
+pub struct PublicKeysValidatorWasm {
+    public_key_validator: PublicKeysValidator<BlsAdapter>,
+    public_key_in_state_transition_validator: PublicKeysValidator<BlsAdapter>,
+}
+
+#[wasm_bindgen(js_class = PublicKeysValidator)]
+impl PublicKeysValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(adapter: JsBlsAdapter) -> Result<PublicKeysValidatorWasm, JsError> {
+        Ok(Self {
+            public_key_validator: PublicKeysValidator::new(BlsAdapter(JsBlsAdapter::from(
+                adapter.clone(),
+            )))?,
+            public_key_in_state_transition_validator: PublicKeysValidator::new_with_schema(
+                PUBLIC_KEY_SCHEMA_FOR_TRANSITION.clone(),
+                BlsAdapter(adapter),
+            )?,
+        })
+    }
+
+    #[wasm_bindgen(js_name=validateKeys)]
+    pub fn validate_keys(
+        &self,
+        public_keys: js_sys::Array,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
+
+        let validation_result = self
+            .public_key_validator
+            .validate_keys(&raw_public_keys)
+            .map_err(|e| JsValue::from(e.to_string()))?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+
+    #[wasm_bindgen(js_name=validatePublicKeyStructure)]
+    pub fn validate_public_key_structure(
+        &self,
+        public_key: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let pk_serde_json = public_key.with_serde_to_json_value()?;
+
+        let validation_result = self
+            .public_key_validator
+            .validate_public_key_structure(&pk_serde_json)
+            .map_err(|e| JsValue::from(e.to_string()))?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+
+    #[wasm_bindgen(js_name=validateKeysInStateTransition)]
+    pub fn validate_keys_in_state_transition(
+        &self,
+        public_keys: js_sys::Array,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
+
+        let validation_result = self
+            .public_key_in_state_transition_validator
+            .validate_keys(&raw_public_keys)
+            .map_err(|e| JsValue::from(e.to_string()))?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity_public_key/public_keys_validator.rs

@@ -34,7 +34,7 @@ impl PublicKeysValidatorWasm {
         &self,
         public_key: JsValue,
     ) -> Result<ValidationResultWasm, JsValue> {
-        let pk_serde_json = public_key.to_serde_json_value()?;
+        let pk_serde_json = public_key.with_serde_to_json_value()?;
 
         self.0
             .validate_public_key_structure(&pk_serde_json)

package/src/lib.rs

@@ -3,9 +3,6 @@ pub use data_contract::*;
 pub use data_contract_factory::*;
 pub use document::*;
 pub use identity::*;
-pub use identity::*;
-pub use identity_facade::*;
-pub use identity_public_key::*;
 pub use metadata::*;
 pub use state_transition::*;
 
@@ -16,14 +13,14 @@ mod document;
 pub mod errors;
 mod identifier;
 mod identity;
-mod identity_facade;
-mod identity_public_key;
 mod metadata;
 mod state_repository;
 mod state_transition;
+mod version;
 
 mod utils;
 
 mod bls_adapter;
 mod buffer;
-pub mod validation_result;
+mod lodash;
+mod validation;

package/src/lodash.rs

@@ -0,0 +1,7 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(module = "lodash")]
+extern "C" {
+    #[wasm_bindgen(js_name = "set")]
+    pub fn lodash_set(object: &JsValue, path: &str, value: JsValue);
+}

package/src/state_repository.rs

@@ -1,19 +1,27 @@
 //! Bindings for state repository -like objects coming from JS.
 
+use serde::{Deserialize, Serialize};
 use std::{convert::Infallible, pin::Pin, sync::Mutex};
 
 use async_trait::async_trait;
+use dpp::dashcore::consensus;
 use dpp::{
     dashcore::InstantLock,
     data_contract::DataContract,
     document::Document,
     prelude::{Identifier, Identity},
-    state_repository::StateRepositoryLike,
+    state_repository::{
+        FetchTransactionResponse as FetchTransactionResponseDPP, StateRepositoryLike,
+    },
     state_transition::state_transition_execution_context::StateTransitionExecutionContext,
 };
 use wasm_bindgen::prelude::*;
 
-use crate::{identifier::IdentifierWrapper, DataContractWasm, StateTransitionExecutionContextWasm};
+use crate::buffer::Buffer;
+use crate::{
+    identifier::IdentifierWrapper, DataContractWasm, IdentityWasm,
+    StateTransitionExecutionContextWasm,
+};
 
 #[wasm_bindgen]
 extern "C" {
@@ -33,6 +41,67 @@ extern "C" {
         execution_context: StateTransitionExecutionContextWasm,
     ) -> JsValue;
 
+    #[wasm_bindgen(structural, method, js_name=fetchIdentity)]
+    pub fn fetch_identity(
+        this: &ExternalStateRepositoryLike,
+        id: IdentifierWrapper,
+        execution_context: StateTransitionExecutionContextWasm,
+    ) -> Option<IdentityWasm>;
+
+    #[wasm_bindgen(structural, method, js_name=fetchLatestPlatformCoreChainLockedHeight)]
+    pub fn fetch_latest_platform_core_chain_locked_height(
+        this: &ExternalStateRepositoryLike,
+    ) -> Option<u32>;
+
+    #[wasm_bindgen(structural, method, js_name=fetchTransaction)]
+    pub fn fetch_transaction(
+        this: &ExternalStateRepositoryLike,
+        id: JsValue,
+        execution_context: StateTransitionExecutionContextWasm,
+    ) -> JsValue;
+
+    #[wasm_bindgen(structural, method, js_name=isAssetLockTransactionOutPointAlreadyUsed)]
+    pub fn is_asset_lock_transaction_out_point_already_used(
+        this: &ExternalStateRepositoryLike,
+        out_point_buffer: Buffer,
+        execution_context: StateTransitionExecutionContextWasm,
+    ) -> bool;
+
+    #[wasm_bindgen(structural, method, js_name=verifyInstantLock)]
+    pub fn verify_instant_lock(
+        this: &ExternalStateRepositoryLike,
+        instant_lock: Vec<u8>,
+        execution_context: StateTransitionExecutionContextWasm,
+    ) -> bool;
+
+    #[wasm_bindgen(structural, method, js_name=createIdentity)]
+    pub fn create_identity(
+        this: &ExternalStateRepositoryLike,
+        identity: IdentityWasm,
+        execution_context: StateTransitionExecutionContextWasm,
+    );
+
+    #[wasm_bindgen(structural, method, js_name=updateIdentity)]
+    pub fn update_identity(
+        this: &ExternalStateRepositoryLike,
+        identity: IdentityWasm,
+        execution_context: StateTransitionExecutionContextWasm,
+    );
+
+    #[wasm_bindgen(structural, method, js_name=storeIdentityPublicKeyHashes)]
+    pub fn store_identity_public_key_hashes(
+        this: &ExternalStateRepositoryLike,
+        identity_id: IdentifierWrapper,
+        public_key_hashes: Vec<Buffer>,
+        execution_context: StateTransitionExecutionContextWasm,
+    );
+
+    #[wasm_bindgen(structural, method, js_name=markAssetLockTransactionOutPointAsUsed)]
+    pub fn mark_asset_lock_transaction_out_point_as_used(
+        this: &ExternalStateRepositoryLike,
+        out_point_buffer: Buffer,
+    );
+
     // TODO add missing declarations
 }
 
@@ -49,10 +118,40 @@ impl ExternalStateRepositoryLikeWrapper {
     }
 }
 
+#[derive(Clone, Serialize, Deserialize)]
+pub struct FetchTransactionResponse {
+    pub height: Option<u32>,
+    pub data: Option<Vec<u8>>,
+}
+
+impl From<JsValue> for FetchTransactionResponse {
+    fn from(v: JsValue) -> Self {
+        if v.is_falsy() {
+            FetchTransactionResponse {
+                height: Some(0),
+                data: None,
+            }
+        } else {
+            serde_wasm_bindgen::from_value(v).unwrap()
+        }
+    }
+}
+
+impl From<FetchTransactionResponse> for FetchTransactionResponseDPP {
+    fn from(v: FetchTransactionResponse) -> Self {
+        FetchTransactionResponseDPP {
+            data: v.data,
+            height: v.height,
+        }
+    }
+}
+
 #[async_trait]
 impl StateRepositoryLike for ExternalStateRepositoryLikeWrapper {
     type ConversionError = Infallible;
     type FetchDataContract = DataContractWasm;
+    type FetchIdentity = IdentityWasm;
+    type FetchTransaction = FetchTransactionResponse;
 
     async fn fetch_data_contract(
         &self,
@@ -121,35 +220,52 @@ impl StateRepositoryLike for ExternalStateRepositoryLikeWrapper {
         todo!()
     }
 
-    async fn fetch_transaction<T>(
+    async fn fetch_transaction(
         &self,
-        _id: &str,
-        _execution_context: &StateTransitionExecutionContext,
-    ) -> anyhow::Result<Option<T>>
-    where
-        T: for<'de> serde::de::Deserialize<'de> + 'static,
-    {
-        todo!()
+        id: &str,
+        execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<Self::FetchTransaction> {
+        let response = self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .fetch_transaction(JsValue::from_str(id), execution_context.into());
+        Ok(FetchTransactionResponse::from(response))
     }
 
-    async fn fetch_identity<T>(
+    async fn fetch_identity(
         &self,
-        _id: &Identifier,
-        _execution_context: &StateTransitionExecutionContext,
-    ) -> anyhow::Result<Option<T>>
-    where
-        T: for<'de> serde::de::Deserialize<'de> + 'static,
-    {
-        todo!()
+        id: &Identifier,
+        execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<Option<Self::FetchIdentity>> {
+        Ok(self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .fetch_identity(id.clone().into(), execution_context.clone().into())
+            .map(Into::into))
     }
 
     async fn store_identity_public_key_hashes(
         &self,
-        _identity_id: &Identifier,
-        _public_key_hashes: Vec<Vec<u8>>,
-        _execution_context: &StateTransitionExecutionContext,
+        identity_id: &Identifier,
+        public_key_hashes: Vec<Vec<u8>>,
+        execution_context: &StateTransitionExecutionContext,
     ) -> anyhow::Result<()> {
-        todo!()
+        let hashes = public_key_hashes
+            .iter()
+            .map(|hash| Buffer::from_bytes(hash))
+            .collect();
+
+        Ok(self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .store_identity_public_key_hashes(
+                identity_id.clone().into(),
+                hashes,
+                execution_context.clone().into(),
+            ))
     }
 
     async fn fetch_identity_by_public_key_hashes<T>(
@@ -169,27 +285,55 @@ impl StateRepositoryLike for ExternalStateRepositoryLikeWrapper {
         todo!()
     }
 
+    async fn fetch_latest_platform_core_chain_locked_height(&self) -> anyhow::Result<Option<u32>> {
+        Ok(self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .fetch_latest_platform_core_chain_locked_height()
+            .map(Into::into))
+    }
+
     async fn verify_instant_lock(
         &self,
-        _instant_lock: &InstantLock,
-        _execution_context: &StateTransitionExecutionContext,
+        instant_lock: &InstantLock,
+        execution_context: &StateTransitionExecutionContext,
     ) -> anyhow::Result<bool> {
-        todo!()
+        let raw_instant_lock = consensus::serialize(instant_lock);
+
+        let verified = self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .verify_instant_lock(raw_instant_lock, execution_context.clone().into());
+
+        Ok(verified)
     }
 
     async fn is_asset_lock_transaction_out_point_already_used(
         &self,
-        _out_point_buffer: &[u8],
-        _execution_context: &StateTransitionExecutionContext,
+        out_point_buffer: &[u8],
+        execution_context: &StateTransitionExecutionContext,
     ) -> anyhow::Result<bool> {
-        todo!()
+        Ok(self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .is_asset_lock_transaction_out_point_already_used(
+                Buffer::from_bytes(out_point_buffer),
+                execution_context.clone().into(),
+            ))
     }
 
     async fn mark_asset_lock_transaction_out_point_as_used(
         &self,
-        _out_point_buffer: &[u8],
+        out_point_buffer: &[u8],
     ) -> anyhow::Result<()> {
-        todo!()
+        Ok(self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .mark_asset_lock_transaction_out_point_as_used(Buffer::from_bytes(out_point_buffer)))
     }
 
     async fn fetch_sml_store<T>(&self) -> anyhow::Result<T>
@@ -201,18 +345,26 @@ impl StateRepositoryLike for ExternalStateRepositoryLikeWrapper {
 
     async fn create_identity(
         &self,
-        _identity: &Identity,
-        _execution_context: &StateTransitionExecutionContext,
+        identity: &Identity,
+        execution_context: &StateTransitionExecutionContext,
     ) -> anyhow::Result<()> {
-        todo!()
+        Ok(self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .create_identity(identity.clone().into(), execution_context.clone().into()))
     }
 
     async fn update_identity(
         &self,
-        _identity: &Identity,
-        _execution_context: &StateTransitionExecutionContext,
+        identity: &Identity,
+        execution_context: &StateTransitionExecutionContext,
     ) -> anyhow::Result<()> {
-        todo!()
+        Ok(self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .update_identity(identity.clone().into(), execution_context.clone().into()))
     }
 
     async fn fetch_latest_withdrawal_transaction_index(&self) -> anyhow::Result<u64> {

package/src/state_transition/mod.rs

@@ -22,6 +22,18 @@ impl<'a> From<&'a StateTransitionExecutionContextWasm> for StateTransitionExecut
     }
 }
 
+impl<'a> From<&'a StateTransitionExecutionContextWasm> for &'a StateTransitionExecutionContext {
+    fn from(wa: &'a StateTransitionExecutionContextWasm) -> Self {
+        &wa.0
+    }
+}
+
+impl<'a> From<&'a StateTransitionExecutionContext> for StateTransitionExecutionContextWasm {
+    fn from(rs: &'a StateTransitionExecutionContext) -> Self {
+        Self(rs.clone())
+    }
+}
+
 #[wasm_bindgen(js_class=StateTransitionExecutionContext)]
 impl StateTransitionExecutionContextWasm {
     #[wasm_bindgen(constructor)]