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

package/src/state_transition/conversion.rs

@@ -0,0 +1,104 @@
+use crate::utils::generic_of_js_val;
+use crate::{
+    DataContractCreateTransitionWasm, DataContractUpdateTransitionWasm,
+    DocumentsBatchTransitionWasm, IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm,
+    IdentityUpdateTransitionWasm,
+};
+use dpp::state_transition::{StateTransition, StateTransitionType};
+use std::convert::TryInto;
+use wasm_bindgen::__rt::Ref;
+use wasm_bindgen::{JsCast, JsError, JsValue};
+
+pub fn state_transition_wasm_to_object(state_transition: &JsValue) -> Result<JsValue, JsValue> {
+    let to_object_value = js_sys::Reflect::get(state_transition, &JsValue::from_str("toObject"))
+        .map_err(|_| JsError::new("No 'toObject' property present in state transition"))?;
+
+    let to_object_function: &js_sys::Function = to_object_value
+        .dyn_ref::<js_sys::Function>()
+        .ok_or_else(|| JsError::new("'toObject' is not a function"))?;
+
+    to_object_function.call0(state_transition)
+}
+
+pub fn create_state_transition_from_wasm_instance(
+    js_value: &JsValue,
+) -> Result<StateTransition, JsValue> {
+    let get_type_value = js_sys::Reflect::get(js_value, &JsValue::from_str("getType"))
+        .map_err(|_| JsError::new("No 'getType' property present in state transition"))?;
+
+    let get_type_function: &js_sys::Function = get_type_value
+        .dyn_ref::<js_sys::Function>()
+        .ok_or_else(|| JsError::new("'getType' is not a function"))?;
+
+    let raw_state_transition_type = get_type_function
+        .call0(js_value)?
+        .as_f64()
+        .ok_or(JsError::new("Error calling 'getType' function"))?
+        as u8;
+
+    let state_transition_type: StateTransitionType =
+        raw_state_transition_type.try_into().map_err(|_| {
+            JsError::new(&format!(
+                "Unknown state transition type: {}",
+                raw_state_transition_type
+            ))
+        })?;
+
+    match state_transition_type {
+        StateTransitionType::DataContractCreate => {
+            let st: Ref<DataContractCreateTransitionWasm> =
+                generic_of_js_val::<DataContractCreateTransitionWasm>(
+                    js_value,
+                    "DataContractCreateTransition",
+                )?;
+
+            Ok(StateTransition::DataContractCreate(st.clone().into()))
+        }
+        StateTransitionType::DocumentsBatch => {
+            let st: Ref<DocumentsBatchTransitionWasm> = generic_of_js_val::<
+                DocumentsBatchTransitionWasm,
+            >(
+                js_value, "DocumentsBatchTransition"
+            )?;
+
+            Ok(StateTransition::DocumentsBatch(st.clone().into()))
+        }
+        StateTransitionType::IdentityCreate => {
+            let st: Ref<IdentityCreateTransitionWasm> = generic_of_js_val::<
+                IdentityCreateTransitionWasm,
+            >(
+                js_value, "IdentityCreateTransition"
+            )?;
+
+            Ok(StateTransition::IdentityCreate(st.clone().into()))
+        }
+        StateTransitionType::IdentityTopUp => {
+            let st: Ref<IdentityTopUpTransitionWasm> = generic_of_js_val::<
+                IdentityTopUpTransitionWasm,
+            >(
+                js_value, "IdentityTopUpTransition"
+            )?;
+
+            Ok(StateTransition::IdentityTopUp(st.clone().into()))
+        }
+        StateTransitionType::DataContractUpdate => {
+            let st: Ref<DataContractUpdateTransitionWasm> =
+                generic_of_js_val::<DataContractUpdateTransitionWasm>(
+                    js_value,
+                    "DataContractUpdateTransition",
+                )?;
+
+            Ok(StateTransition::DataContractUpdate(st.clone().into()))
+        }
+        StateTransitionType::IdentityUpdate => {
+            let st: Ref<IdentityUpdateTransitionWasm> = generic_of_js_val::<
+                IdentityUpdateTransitionWasm,
+            >(
+                js_value, "IdentityUpdateTransition"
+            )?;
+
+            Ok(StateTransition::IdentityUpdate(st.clone().into()))
+        }
+        _ => Err(JsError::new("Unsupported state transition type").into()),
+    }
+}

package/src/state_transition/errors/invalid_state_transition_error.rs

@@ -0,0 +1,32 @@
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
+
+use crate::errors::consensus_error::from_consensus_error_ref;
+
+#[wasm_bindgen(js_name = InvalidStateTransitionError)]
+pub struct InvalidStateTransitionErrorWasm {
+    errors: Vec<ConsensusError>,
+    raw_state_transition: JsValue,
+}
+
+impl InvalidStateTransitionErrorWasm {
+    pub fn new(errors: Vec<ConsensusError>, raw_state_transition: JsValue) -> Self {
+        Self {
+            errors,
+            raw_state_transition,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class = InvalidStateTransitionError)]
+impl InvalidStateTransitionErrorWasm {
+    #[wasm_bindgen(js_name = getErrors)]
+    pub fn get_errors(&self) -> Vec<JsValue> {
+        self.errors.iter().map(from_consensus_error_ref).collect()
+    }
+
+    #[wasm_bindgen(js_name = getRawStateTransition)]
+    pub fn get_raw_state_transition(&self) -> JsValue {
+        self.raw_state_transition.clone()
+    }
+}

package/src/state_transition/errors/mod.rs

@@ -0,0 +1 @@
+pub mod invalid_state_transition_error;

package/src/state_transition/mod.rs

@@ -1,7 +1,19 @@
 use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
+
 use wasm_bindgen::prelude::*;
 
+pub mod errors;
+pub mod state_transition_facade;
+pub mod state_transition_factory;
+
+pub mod validation;
+use crate::utils::Inner;
+pub use validation::*;
+
+pub(crate) mod conversion;
+
 #[wasm_bindgen(js_name=StateTransitionExecutionContext)]
+#[derive(Clone)]
 pub struct StateTransitionExecutionContextWasm(StateTransitionExecutionContext);
 
 impl From<StateTransitionExecutionContext> for StateTransitionExecutionContextWasm {
@@ -22,6 +34,24 @@ 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())
+    }
+}
+
+impl Default for StateTransitionExecutionContextWasm {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[wasm_bindgen(js_class=StateTransitionExecutionContext)]
 impl StateTransitionExecutionContextWasm {
     #[wasm_bindgen(constructor)]
@@ -39,3 +69,19 @@ impl StateTransitionExecutionContextWasm {
         self.0.disable_dry_run();
     }
 }
+
+impl Inner for StateTransitionExecutionContextWasm {
+    type InnerItem = StateTransitionExecutionContext;
+
+    fn into_inner(self) -> Self::InnerItem {
+        self.0
+    }
+
+    fn inner(&self) -> &Self::InnerItem {
+        &self.0
+    }
+
+    fn inner_mut(&mut self) -> &mut Self::InnerItem {
+        &mut self.0
+    }
+}

package/src/state_transition/state_transition_facade.rs

@@ -0,0 +1,263 @@
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
+use crate::state_transition_factory::StateTransitionFactoryWasm;
+use crate::utils::ToSerdeJSONExt;
+use crate::validation::ValidationResultWasm;
+use crate::with_js_error;
+use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
+use dpp::state_transition::{StateTransitionFacade, StateTransitionLike, ValidateOptions};
+use dpp::version::ProtocolVersionValidator;
+use serde::Deserialize;
+
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
+
+#[derive(Clone)]
+#[wasm_bindgen(js_name = StateTransitionFacade)]
+pub struct StateTransitionFacadeWasm(
+    StateTransitionFacade<ExternalStateRepositoryLikeWrapper, BlsAdapter>,
+);
+
+impl StateTransitionFacadeWasm {
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+        bls_adapter: JsBlsAdapter,
+        protocol_version_validator: Arc<ProtocolVersionValidator>,
+    ) -> Result<StateTransitionFacadeWasm, JsValue> {
+        let state_repository_wrapper = ExternalStateRepositoryLikeWrapper::new(state_repository);
+
+        let adapter = BlsAdapter(bls_adapter);
+
+        let state_transition_facade = StateTransitionFacade::new(
+            state_repository_wrapper,
+            adapter,
+            protocol_version_validator,
+        )
+        .map_err(from_dpp_err)?;
+
+        Ok(StateTransitionFacadeWasm(state_transition_facade))
+    }
+}
+
+#[wasm_bindgen(js_class = StateTransitionFacade)]
+impl StateTransitionFacadeWasm {
+    #[wasm_bindgen(js_name = createFromObject)]
+    pub async fn create_from_object(
+        &self,
+        raw_state_transition: JsValue,
+        options: JsValue,
+    ) -> Result<JsValue, JsValue> {
+        let options: FromObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let raw_state_transition = raw_state_transition.with_serde_to_json_value()?;
+
+        let result = self
+            .0
+            .create_from_object(
+                raw_state_transition,
+                options.skip_validation.unwrap_or(false),
+            )
+            .await;
+
+        StateTransitionFactoryWasm::state_transition_wasm_from_factory_result(result)
+    }
+
+    #[wasm_bindgen(js_name = createFromBuffer)]
+    pub async fn create_from_buffer(
+        &self,
+        state_transition_buffer: Vec<u8>,
+        options: JsValue,
+    ) -> Result<JsValue, JsValue> {
+        let options: FromObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let result = self
+            .0
+            .create_from_buffer(
+                &state_transition_buffer,
+                options.skip_validation.unwrap_or(false),
+            )
+            .await;
+
+        StateTransitionFactoryWasm::state_transition_wasm_from_factory_result(result)
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        raw_state_transition: JsValue,
+        options: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let options: ValidateOptionsWasm = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let (state_transition, state_transition_json, execution_context) =
+            if let Ok(state_transition) =
+                super::super::conversion::create_state_transition_from_wasm_instance(
+                    &raw_state_transition,
+                )
+            {
+                let execution_context = state_transition.get_execution_context().to_owned();
+                // TODO: revisit after https://github.com/dashpay/platform/pull/809 is merged
+                //  we use this workaround to produce JSON value for validation because
+                //  state_transition.to_object() returns value that does not pass basic validation
+                let state_transition_json =
+                    super::super::conversion::state_transition_wasm_to_object(
+                        &raw_state_transition,
+                    )?
+                    .with_serde_to_json_value()?;
+                (state_transition, state_transition_json, execution_context)
+            } else {
+                let state_transition_json = raw_state_transition.with_serde_to_json_value()?;
+                let execution_context = StateTransitionExecutionContext::default();
+                let state_transition = self
+                    .0
+                    .create_from_object(state_transition_json.clone(), true)
+                    .await
+                    .map_err(from_dpp_err)?;
+                (state_transition, state_transition_json, execution_context)
+            };
+
+        let validation_result = self
+            .0
+            .validate(
+                &state_transition,
+                &state_transition_json,
+                &execution_context,
+                options.into(),
+            )
+            .await
+            .map_err(from_dpp_err)?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+
+    #[wasm_bindgen(js_name = validateBasic)]
+    pub async fn validate_basic(
+        &self,
+        raw_state_transition: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let state_transition_json;
+        let execution_context;
+
+        if let Ok(state_transition) =
+            super::super::conversion::create_state_transition_from_wasm_instance(
+                &raw_state_transition,
+            )
+        {
+            execution_context = state_transition.get_execution_context().to_owned();
+            // TODO: revisit after https://github.com/dashpay/platform/pull/809 is merged
+            //  we use this workaround to produce JSON value for validation because
+            //  state_transition.to_object() returns value that does not pass basic validation
+            state_transition_json =
+                super::super::conversion::state_transition_wasm_to_object(&raw_state_transition)?
+                    .with_serde_to_json_value()?;
+        } else {
+            state_transition_json = raw_state_transition.with_serde_to_json_value()?;
+            execution_context = StateTransitionExecutionContext::default();
+        }
+
+        let validation_result = self
+            .0
+            .validate_basic(&state_transition_json, &execution_context)
+            .await
+            .map_err(from_dpp_err)?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+
+    #[wasm_bindgen(js_name = validateSignature)]
+    pub async fn validate_signature(
+        &self,
+        raw_state_transition: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let state_transition =
+            super::super::conversion::create_state_transition_from_wasm_instance(
+                &raw_state_transition,
+            )?;
+
+        let validation_result = self
+            .0
+            .validate_signature(state_transition)
+            .await
+            .map_err(from_dpp_err)?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+
+    #[wasm_bindgen(js_name = validateFee)]
+    pub async fn validate_fee(
+        &self,
+        raw_state_transition: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let state_transition =
+            super::super::conversion::create_state_transition_from_wasm_instance(
+                &raw_state_transition,
+            )?;
+
+        let validation_result = self
+            .0
+            .validate_fee(&state_transition)
+            .await
+            .map_err(from_dpp_err)?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+
+    #[wasm_bindgen(js_name = validateState)]
+    pub async fn validate_state(
+        &self,
+        raw_state_transition: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let state_transition =
+            super::super::conversion::create_state_transition_from_wasm_instance(
+                &raw_state_transition,
+            )?;
+
+        let validation_result = self
+            .0
+            .validate_state(&state_transition)
+            .await
+            .map_err(from_dpp_err)?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct FromObjectOptions {
+    pub skip_validation: Option<bool>,
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct ValidateOptionsWasm {
+    pub basic: Option<bool>,
+    pub signature: Option<bool>,
+    pub fee: Option<bool>,
+    pub state: Option<bool>,
+}
+
+impl From<ValidateOptionsWasm> for ValidateOptions {
+    fn from(options: ValidateOptionsWasm) -> Self {
+        Self {
+            basic: options.basic.unwrap_or(true),
+            signature: options.signature.unwrap_or(true),
+            fee: options.fee.unwrap_or(true),
+            state: options.state.unwrap_or(true),
+        }
+    }
+}

package/src/state_transition/state_transition_factory.rs

@@ -0,0 +1,216 @@
+use std::{ops::Deref, sync::Arc};
+
+use serde_json::Value as JsonValue;
+
+use dpp::{state_transition::{
+    validation::{
+        validate_state_transition_basic::StateTransitionBasicValidator,
+        validate_state_transition_by_type::StateTransitionByTypeValidator,
+    },
+    StateTransitionFactory, StateTransitionFactoryOptions, StateTransition, errors::StateTransitionError,
+}, version::ProtocolVersionValidator, data_contract::state_transition::{data_contract_create_transition::validation::state::validate_data_contract_create_transition_basic::DataContractCreateTransitionBasicValidator, data_contract_update_transition::validation::basic::DataContractUpdateTransitionBasicValidator}, identity::{state_transition::{identity_create_transition::validation::basic::IdentityCreateTransitionBasicValidator, validate_public_key_signatures::{PublicKeysSignaturesValidator}, asset_lock_proof::{AssetLockProofValidator, ChainAssetLockProofStructureValidator, InstantAssetLockProofStructureValidator, AssetLockTransactionValidator}, identity_topup_transition::validation::basic::IdentityTopUpTransitionBasicValidator, identity_credit_withdrawal_transition::validation::basic::validate_identity_credit_withdrawal_transition_basic::IdentityCreditWithdrawalTransitionBasicValidator, identity_update_transition::validate_identity_update_transition_basic::ValidateIdentityUpdateTransitionBasic}, validation::PublicKeysValidator}, document::validation::basic::validate_documents_batch_transition_basic::DocumentBatchTransitionBasicValidator, ProtocolError};
+use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
+
+use crate::utils::ToSerdeJSONExt;
+use crate::{
+    bls_adapter::{BlsAdapter, JsBlsAdapter},
+    errors::{from_dpp_err, from_dpp_init_error},
+    identity_facade::FromObjectOptions,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    state_transition::errors::invalid_state_transition_error::InvalidStateTransitionErrorWasm,
+    with_js_error, DataContractCreateTransitionWasm, DataContractUpdateTransitionWasm,
+    DocumentsBatchTransitionWasm, IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm,
+    IdentityUpdateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name = StateTransitionFactory)]
+pub struct StateTransitionFactoryWasm(
+    StateTransitionFactory<ExternalStateRepositoryLikeWrapper, BlsAdapter>,
+);
+
+impl From<StateTransitionFactory<ExternalStateRepositoryLikeWrapper, BlsAdapter>>
+    for StateTransitionFactoryWasm
+{
+    fn from(
+        factory: StateTransitionFactory<ExternalStateRepositoryLikeWrapper, BlsAdapter>,
+    ) -> Self {
+        Self(factory)
+    }
+}
+
+impl StateTransitionFactoryWasm {
+    pub fn state_transition_wasm_from_factory_result(
+        result: Result<StateTransition, ProtocolError>,
+    ) -> Result<JsValue, JsValue> {
+        match result {
+            Ok(state_transition) => match state_transition {
+                StateTransition::DataContractCreate(st) => {
+                    Ok(DataContractCreateTransitionWasm::from(st).into())
+                }
+                StateTransition::DataContractUpdate(st) => {
+                    Ok(DataContractUpdateTransitionWasm::from(st).into())
+                }
+                StateTransition::IdentityCreate(st) => {
+                    Ok(IdentityCreateTransitionWasm::from(st).into())
+                }
+                StateTransition::IdentityUpdate(st) => {
+                    Ok(IdentityUpdateTransitionWasm::from(st).into())
+                }
+                StateTransition::IdentityTopUp(st) => {
+                    Ok(IdentityTopUpTransitionWasm::from(st).into())
+                }
+                StateTransition::DocumentsBatch(st) => {
+                    Ok(DocumentsBatchTransitionWasm::from(st).into())
+                }
+                _ => Err("Unsupported state transition type".into()),
+            },
+            Err(dpp::ProtocolError::StateTransitionError(e)) => match e {
+                StateTransitionError::InvalidStateTransitionError {
+                    errors,
+                    raw_state_transition,
+                } => Err(InvalidStateTransitionErrorWasm::new(
+                    errors,
+                    serde_wasm_bindgen::to_value(&raw_state_transition)?,
+                )
+                .into()),
+            },
+            Err(other) => Err(from_dpp_err(other)),
+        }
+    }
+}
+
+#[wasm_bindgen(js_class = StateTransitionFactory)]
+impl StateTransitionFactoryWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+        bls_adapter: JsBlsAdapter,
+    ) -> Result<StateTransitionFactoryWasm, JsValue> {
+        let state_repository_wrapper =
+            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+        let protocol_version_validator = Arc::new(ProtocolVersionValidator::default());
+
+        let adapter = BlsAdapter(bls_adapter);
+
+        let pk_validator =
+            Arc::new(PublicKeysValidator::new(adapter.clone()).map_err(from_dpp_init_error)?);
+        let pk_sig_validator = Arc::new(PublicKeysSignaturesValidator::new(adapter.clone()));
+
+        let asset_lock_tx_validator = Arc::new(AssetLockTransactionValidator::new(
+            state_repository_wrapper.clone(),
+        ));
+
+        let asset_lock_validator = Arc::new(AssetLockProofValidator::new(
+            InstantAssetLockProofStructureValidator::new(
+                state_repository_wrapper.clone(),
+                asset_lock_tx_validator.clone(),
+            )
+            .map_err(from_dpp_init_error)?,
+            ChainAssetLockProofStructureValidator::new(
+                state_repository_wrapper.clone(),
+                asset_lock_tx_validator,
+            )
+            .map_err(from_dpp_init_error)?,
+        ));
+
+        let factory = StateTransitionFactory::new(
+            state_repository_wrapper.clone(),
+            StateTransitionBasicValidator::new(
+                state_repository_wrapper.clone(),
+                StateTransitionByTypeValidator::new(
+                    DataContractCreateTransitionBasicValidator::new(
+                        protocol_version_validator.clone(),
+                    )
+                    .map_err(from_dpp_err)?,
+                    DataContractUpdateTransitionBasicValidator::new(
+                        state_repository_wrapper.clone(),
+                        protocol_version_validator.clone(),
+                    )
+                    .map_err(from_dpp_init_error)?,
+                    IdentityCreateTransitionBasicValidator::new(
+                        protocol_version_validator.deref().clone(),
+                        pk_validator.clone(),
+                        pk_validator.clone(),
+                        asset_lock_validator.clone(),
+                        adapter,
+                        pk_sig_validator.clone(),
+                    )
+                    .map_err(from_dpp_init_error)?,
+                    ValidateIdentityUpdateTransitionBasic::new(
+                        ProtocolVersionValidator::default(),
+                        pk_validator,
+                        pk_sig_validator,
+                    )
+                    .map_err(from_dpp_err)?,
+                    IdentityTopUpTransitionBasicValidator::new(
+                        ProtocolVersionValidator::default(),
+                        asset_lock_validator,
+                    )
+                    .map_err(from_dpp_init_error)?,
+                    IdentityCreditWithdrawalTransitionBasicValidator::new(
+                        protocol_version_validator.clone(),
+                    )
+                    .map_err(from_dpp_init_error)?,
+                    DocumentBatchTransitionBasicValidator::new(
+                        state_repository_wrapper,
+                        protocol_version_validator.clone(),
+                    ),
+                ),
+            ),
+        );
+
+        Ok(factory.into())
+    }
+
+    #[wasm_bindgen(js_name=createFromObject)]
+    pub async fn create_from_object(
+        &self,
+        state_transition_object: JsValue,
+        options: JsValue,
+    ) -> Result<JsValue, JsValue> {
+        let options: FromObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let raw_state_transition: JsonValue = state_transition_object.with_serde_to_json_value()?;
+
+        let result = self
+            .0
+            .create_from_object(
+                raw_state_transition,
+                Some(StateTransitionFactoryOptions {
+                    skip_validation: options.skip_validation.unwrap_or(false),
+                }),
+            )
+            .await;
+
+        Self::state_transition_wasm_from_factory_result(result)
+    }
+
+    #[wasm_bindgen(js_name=createFromBuffer)]
+    pub async fn create_from_buffer(
+        &self,
+        buffer: Vec<u8>,
+        options: JsValue,
+    ) -> Result<JsValue, JsValue> {
+        let options: FromObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let result = self
+            .0
+            .create_from_buffer(
+                &buffer,
+                Some(StateTransitionFactoryOptions {
+                    skip_validation: options.skip_validation.unwrap_or(false),
+                }),
+            )
+            .await;
+
+        Self::state_transition_wasm_from_factory_result(result)
+    }
+}

package/src/state_transition/validation/mod.rs

@@ -0,0 +1 @@
+pub mod validate_state_transition_key_signature;