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

package/src/{identity.rs → identity/mod.rs}

@@ -1,3 +1,7 @@
+pub mod identity_facade;
+mod identity_public_key;
+mod validation;
+
 use js_sys::Array;
 use serde_json::Value;
 use wasm_bindgen::prelude::*;
@@ -12,8 +16,8 @@ use crate::errors::from_dpp_err;
 use crate::identifier::IdentifierWrapper;
 use crate::utils;
 use crate::utils::to_vec_of_serde_values;
-use crate::IdentityPublicKeyWasm;
 use crate::MetadataWasm;
+pub use identity_public_key::*;
 
 #[wasm_bindgen(js_name=Identity)]
 #[derive(Clone)]
@@ -60,12 +64,7 @@ impl IdentityWasm {
             .into_iter()
             .map(IdentityPublicKey::from_json_object)
             .collect::<Result<_, _>>()
-            .map_err(|e| {
-                format!(
-                    "converting to collection of IdentityPublicKeys failed: {:#}",
-                    e
-                )
-            })?;
+            .map_err(|e| format!("converting to collection of IdentityPublicKeys failed: {e:#}"))?;
 
         self.0.set_public_keys(public_keys);
 

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,70 @@
+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())?;
+
+        self.public_key_validator
+            .validate_keys(&raw_public_keys)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name=validatePublicKeyStructure)]
+    pub fn validate_public_key_structure(
+        &self,
+        public_key: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let pk_serde_json = public_key.to_serde_json_value()?;
+
+        self.public_key_validator
+            .validate_public_key_structure(&pk_serde_json)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+
+    #[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())?;
+
+        self.public_key_in_state_transition_validator
+            .validate_keys(&raw_public_keys)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+}

package/src/lib.rs

@@ -1,14 +1,10 @@
-extern crate web_sys;
-
 pub use dash_platform_protocol::*;
 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::*;
 
 mod dash_platform_protocol;
 mod data_contract;
@@ -17,12 +13,12 @@ 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 utils;
 
 mod bls_adapter;
 mod buffer;
-pub mod validation_result;
+mod validation;

package/src/state_repository.rs

@@ -0,0 +1,229 @@
+//! Bindings for state repository -like objects coming from JS.
+
+use std::{convert::Infallible, pin::Pin, sync::Mutex};
+
+use async_trait::async_trait;
+use dpp::{
+    dashcore::InstantLock,
+    data_contract::DataContract,
+    document::Document,
+    prelude::{Identifier, Identity},
+    state_repository::StateRepositoryLike,
+    state_transition::state_transition_execution_context::StateTransitionExecutionContext,
+};
+use wasm_bindgen::prelude::*;
+
+use crate::{identifier::IdentifierWrapper, DataContractWasm, StateTransitionExecutionContextWasm};
+
+#[wasm_bindgen]
+extern "C" {
+    pub type ExternalStateRepositoryLike;
+
+    #[wasm_bindgen(structural, method, js_name=fetchDataContract)]
+    pub fn fetch_data_contract(
+        this: &ExternalStateRepositoryLike,
+        data_contract_id: IdentifierWrapper,
+        execution_context: StateTransitionExecutionContextWasm,
+    ) -> Option<DataContractWasm>;
+
+    #[wasm_bindgen(structural, method, js_name=storeDataContract)]
+    pub fn store_data_contract(
+        this: &ExternalStateRepositoryLike,
+        data_contract: DataContractWasm,
+        execution_context: StateTransitionExecutionContextWasm,
+    ) -> JsValue;
+
+    // TODO add missing declarations
+}
+
+/// Wraps external duck-typed thing into pinned box with mutex to ensure it'll stay at the same
+/// place in memory and will have synchronized access.
+pub(crate) struct ExternalStateRepositoryLikeWrapper(Pin<Box<Mutex<ExternalStateRepositoryLike>>>); // bruh
+
+unsafe impl Send for ExternalStateRepositoryLikeWrapper {}
+unsafe impl Sync for ExternalStateRepositoryLikeWrapper {}
+
+impl ExternalStateRepositoryLikeWrapper {
+    pub(crate) fn new(state_repository: ExternalStateRepositoryLike) -> Self {
+        ExternalStateRepositoryLikeWrapper(Box::pin(Mutex::new(state_repository)))
+    }
+}
+
+#[async_trait]
+impl StateRepositoryLike for ExternalStateRepositoryLikeWrapper {
+    type ConversionError = Infallible;
+    type FetchDataContract = DataContractWasm;
+
+    async fn fetch_data_contract(
+        &self,
+        data_contract_id: &Identifier,
+        execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<Option<Self::FetchDataContract>> {
+        Ok(self
+            .0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .fetch_data_contract(
+                data_contract_id.clone().into(),
+                execution_context.clone().into(),
+            )
+            .map(Into::into))
+    }
+
+    async fn store_data_contract(
+        &self,
+        data_contract: DataContract,
+        execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<()> {
+        self.0
+            .lock()
+            .expect("unexpected concurrency issue!")
+            .store_data_contract(data_contract.into(), execution_context.clone().into());
+        Ok(())
+    }
+
+    async fn fetch_documents<T>(
+        &self,
+        _contract_id: &Identifier,
+        _data_contract_type: &str,
+        _where_query: serde_json::Value,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<Vec<T>>
+    where
+        T: for<'de> serde::de::Deserialize<'de> + 'static,
+    {
+        todo!()
+    }
+
+    async fn create_document(
+        &self,
+        _document: &Document,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<()> {
+        todo!()
+    }
+
+    async fn update_document(
+        &self,
+        _document: &Document,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<()> {
+        todo!()
+    }
+
+    async fn remove_document(
+        &self,
+        _data_contract: &DataContract,
+        _data_contract_type: &str,
+        _document_id: &Identifier,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<()> {
+        todo!()
+    }
+
+    async fn fetch_transaction<T>(
+        &self,
+        _id: &str,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<Option<T>>
+    where
+        T: for<'de> serde::de::Deserialize<'de> + 'static,
+    {
+        todo!()
+    }
+
+    async fn fetch_identity<T>(
+        &self,
+        _id: &Identifier,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<Option<T>>
+    where
+        T: for<'de> serde::de::Deserialize<'de> + 'static,
+    {
+        todo!()
+    }
+
+    async fn store_identity_public_key_hashes(
+        &self,
+        _identity_id: &Identifier,
+        _public_key_hashes: Vec<Vec<u8>>,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<()> {
+        todo!()
+    }
+
+    async fn fetch_identity_by_public_key_hashes<T>(
+        &self,
+        _public_key_hashed: Vec<Vec<u8>>,
+    ) -> anyhow::Result<Vec<T>>
+    where
+        T: for<'de> serde::de::Deserialize<'de> + 'static,
+    {
+        todo!()
+    }
+
+    async fn fetch_latest_platform_block_header<T>(&self) -> anyhow::Result<T>
+    where
+        T: for<'de> serde::de::Deserialize<'de> + 'static,
+    {
+        todo!()
+    }
+
+    async fn verify_instant_lock(
+        &self,
+        _instant_lock: &InstantLock,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<bool> {
+        todo!()
+    }
+
+    async fn is_asset_lock_transaction_out_point_already_used(
+        &self,
+        _out_point_buffer: &[u8],
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<bool> {
+        todo!()
+    }
+
+    async fn mark_asset_lock_transaction_out_point_as_used(
+        &self,
+        _out_point_buffer: &[u8],
+    ) -> anyhow::Result<()> {
+        todo!()
+    }
+
+    async fn fetch_sml_store<T>(&self) -> anyhow::Result<T>
+    where
+        T: for<'de> serde::de::Deserialize<'de> + 'static,
+    {
+        todo!()
+    }
+
+    async fn create_identity(
+        &self,
+        _identity: &Identity,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<()> {
+        todo!()
+    }
+
+    async fn update_identity(
+        &self,
+        _identity: &Identity,
+        _execution_context: &StateTransitionExecutionContext,
+    ) -> anyhow::Result<()> {
+        todo!()
+    }
+
+    async fn fetch_latest_withdrawal_transaction_index(&self) -> anyhow::Result<u64> {
+        todo!()
+    }
+
+    async fn enqueue_withdrawal_transaction(
+        &self,
+        _index: u64,
+        _transaction_bytes: Vec<u8>,
+    ) -> anyhow::Result<()> {
+        todo!()
+    }
+}

package/src/state_transition/mod.rs

@@ -0,0 +1,41 @@
+use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=StateTransitionExecutionContext)]
+pub struct StateTransitionExecutionContextWasm(StateTransitionExecutionContext);
+
+impl From<StateTransitionExecutionContext> for StateTransitionExecutionContextWasm {
+    fn from(rs: StateTransitionExecutionContext) -> Self {
+        StateTransitionExecutionContextWasm(rs)
+    }
+}
+
+impl From<StateTransitionExecutionContextWasm> for StateTransitionExecutionContext {
+    fn from(wa: StateTransitionExecutionContextWasm) -> Self {
+        wa.0
+    }
+}
+
+impl<'a> From<&'a StateTransitionExecutionContextWasm> for StateTransitionExecutionContext {
+    fn from(wa: &StateTransitionExecutionContextWasm) -> Self {
+        wa.0.clone()
+    }
+}
+
+#[wasm_bindgen(js_class=StateTransitionExecutionContext)]
+impl StateTransitionExecutionContextWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> StateTransitionExecutionContextWasm {
+        StateTransitionExecutionContext::default().into()
+    }
+
+    #[wasm_bindgen(js_name=enableDryRun)]
+    pub fn enable_dry_run(&self) {
+        self.0.enable_dry_run();
+    }
+
+    #[wasm_bindgen(js_name=disableDryRun)]
+    pub fn disable_dry_run(&self) {
+        self.0.disable_dry_run();
+    }
+}

package/src/utils.rs

@@ -41,8 +41,8 @@ where
 pub fn to_serde_json_value(data: &JsValue) -> Result<Value, JsValue> {
     let data = stringify(data)?;
     let value: Value = serde_json::from_str(&data)
-        .with_context(|| format!("cant convert {:#?} to serde json value", data))
-        .map_err(|e| format!("{:#}", e))?;
+        .with_context(|| format!("cant convert {data:#?} to serde json value"))
+        .map_err(|e| format!("{e:#}"))?;
     Ok(value)
 }
 

package/src/validation/mod.rs

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

package/test/integration/identity/stateTransition/IdentityUpdateTransition/validation/state/validateIdentityUpdateTransitionStateFactory.spec.js

@@ -36,7 +36,7 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
 
     blockTime = Date.now();
 
-    stateRepositoryMock.fetchLatestPlatformBlockTime.returns(blockTime);
+    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTime);
 
     validateIdentityUpdateTransitionState = validateIdentityUpdateTransitionStateFactory(
       stateRepositoryMock,