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

package/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof_structure_validator.rs

@@ -0,0 +1,72 @@
+use dpp::identity::state_transition::asset_lock_proof::{
+    AssetLockTransactionValidator, InstantAssetLockProofStructureValidator,
+};
+use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
+use dpp::ProtocolError;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+use crate::utils::ToSerdeJSONExt;
+use crate::{
+    errors::from_dpp_err,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation::ValidationResultWasm,
+    StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name = InstantAssetLockProofStructureValidator)]
+pub struct InstantAssetLockProofStructureValidatorWasm(
+    InstantAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>,
+);
+
+impl From<InstantAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>>
+    for InstantAssetLockProofStructureValidatorWasm
+{
+    fn from(
+        validator: InstantAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>,
+    ) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class = InstantAssetLockProofStructureValidator)]
+impl InstantAssetLockProofStructureValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> Result<InstantAssetLockProofStructureValidatorWasm, JsValue> {
+        let state_repository_wrapper =
+            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+        let tx_validator = Arc::new(AssetLockTransactionValidator::new(
+            state_repository_wrapper.clone(),
+        ));
+
+        let validator =
+            InstantAssetLockProofStructureValidator::new(state_repository_wrapper, tx_validator)
+                .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+        Ok(validator.into())
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        raw_asset_lock_proof: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let asset_lock_proof_json = raw_asset_lock_proof.with_serde_to_json_value()?;
+
+        let context: &StateTransitionExecutionContext = execution_context.into();
+        let validation_result = self
+            .0
+            .validate(&asset_lock_proof_json, context)
+            .await
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result
+            .map(|item| JsValue::from(Buffer::from_bytes(&item)))
+            .into())
+    }
+}

package/src/identity/state_transition/asset_lock_proof/instant/mod.rs

@@ -0,0 +1,4 @@
+pub use instant_asset_lock_proof::*;
+
+pub mod instant_asset_lock_proof;
+pub mod instant_asset_lock_proof_structure_validator;

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

@@ -0,0 +1,269 @@
+mod chain;
+mod instant;
+
+pub use chain::*;
+pub use instant::*;
+use std::convert::TryInto;
+use std::sync::Arc;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::__rt::Ref;
+
+use crate::errors::{from_dpp_err, RustConversionError};
+use dpp::dashcore::consensus;
+use dpp::dashcore::hashes::hex::FromHex;
+use dpp::identity::errors::UnknownAssetLockProofTypeError;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+use crate::errors::dpp_error::from_dpp_error_ref;
+use crate::identifier::IdentifierWrapper;
+use crate::identity::errors::UnknownAssetLockProofTypeErrorWasm;
+use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
+use crate::utils::generic_of_js_val;
+use crate::validation::ValidationResultWasm;
+use crate::{Deserialize, StateTransitionExecutionContextWasm};
+use dpp::identity::state_transition::asset_lock_proof::{
+    AssetLockProof, AssetLockProofType, AssetLockPublicKeyHashFetcher,
+    AssetLockTransactionOutputFetcher, AssetLockTransactionValidator,
+};
+
+#[derive(Deserialize, Clone)]
+#[wasm_bindgen(js_name=AssetLockProof)]
+pub struct AssetLockProofWasm(AssetLockProof);
+
+impl From<AssetLockProof> for AssetLockProofWasm {
+    fn from(v: AssetLockProof) -> Self {
+        AssetLockProofWasm(v)
+    }
+}
+
+impl From<AssetLockProofWasm> for AssetLockProof {
+    fn from(v: AssetLockProofWasm) -> Self {
+        v.0
+    }
+}
+
+impl From<InstantAssetLockProofWasm> for AssetLockProofWasm {
+    fn from(f: InstantAssetLockProofWasm) -> Self {
+        AssetLockProof::Instant(f.into()).into()
+    }
+}
+
+impl From<ChainAssetLockProofWasm> for AssetLockProofWasm {
+    fn from(f: ChainAssetLockProofWasm) -> Self {
+        AssetLockProof::Chain(f.into()).into()
+    }
+}
+
+pub trait AssetLockProofLike {
+    fn to_object(&self) -> Result<JsValue, JsValue>;
+}
+
+#[wasm_bindgen(js_class = AssetLockProof)]
+impl AssetLockProofWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_asset_lock_proof: JsValue) -> Result<AssetLockProofWasm, JsValue> {
+        let lock_type = get_lock_type(&raw_asset_lock_proof)?;
+
+        match lock_type {
+            AssetLockProofType::Instant => {
+                Ok(InstantAssetLockProofWasm::new(raw_asset_lock_proof)?.into())
+            }
+            AssetLockProofType::Chain => {
+                Ok(ChainAssetLockProofWasm::new(raw_asset_lock_proof)?.into())
+            }
+        }
+    }
+
+    #[wasm_bindgen(js_name=createIdentifier)]
+    pub fn create_identifier(&self) -> Result<IdentifierWrapper, JsValue> {
+        match &self.0 {
+            AssetLockProof::Instant(instant) => {
+                InstantAssetLockProofWasm::from(instant.to_owned()).create_identifier()
+            }
+            AssetLockProof::Chain(chain) => {
+                ChainAssetLockProofWasm::from(chain.to_owned()).create_identifier()
+            }
+        }
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        match &self.0 {
+            AssetLockProof::Instant(instant) => {
+                InstantAssetLockProofWasm::from(instant.to_owned()).to_object()
+            }
+            AssetLockProof::Chain(chain) => {
+                ChainAssetLockProofWasm::from(chain.to_owned()).to_object()
+            }
+        }
+    }
+}
+
+fn get_lock_type(raw_asset_lock_proof: &JsValue) -> Result<AssetLockProofType, JsValue> {
+    (js_sys::Reflect::get(raw_asset_lock_proof, &JsValue::from_str("type"))
+        .map_err(|_| {
+            RustConversionError::Error(String::from("error getting type from raw asset lock"))
+                .to_js_value()
+        })?
+        .as_f64()
+        .ok_or_else(|| JsValue::from_str("asset lock type must be a number"))? as u64)
+        .try_into()
+        .map_err(|_| JsValue::from_str("unrecognized asset lock proof type"))
+}
+
+#[wasm_bindgen(js_name=createAssetLockProofInstance)]
+pub fn create_asset_lock_proof_instance(raw_parameters: JsValue) -> Result<JsValue, JsValue> {
+    let lock_type = get_lock_type(&raw_parameters)?;
+
+    match lock_type {
+        AssetLockProofType::Instant => {
+            InstantAssetLockProofWasm::new(raw_parameters).map(|v| v.into())
+        }
+        AssetLockProofType::Chain => ChainAssetLockProofWasm::new(raw_parameters).map(|v| v.into()),
+    }
+}
+
+pub fn create_asset_lock_proof_from_wasm_instance(
+    js_value: &JsValue,
+) -> Result<AssetLockProof, JsValue> {
+    let default_error: UnknownAssetLockProofTypeErrorWasm =
+        UnknownAssetLockProofTypeError::new(None).into();
+
+    let get_type_value = js_sys::Reflect::get(js_value, &JsValue::from_str("getType"))
+        .map_err(|_| default_error.clone())?;
+
+    let get_type_function: &js_sys::Function = get_type_value
+        .dyn_ref::<js_sys::Function>()
+        .ok_or_else(|| default_error.clone())?;
+
+    let raw_lock_type = get_type_function
+        .call0(js_value)?
+        .as_f64()
+        .ok_or(default_error)? as u64;
+
+    let lock_type: AssetLockProofType = raw_lock_type.try_into().map_err(|_| {
+        UnknownAssetLockProofTypeErrorWasm::from(UnknownAssetLockProofTypeError::new(Some(
+            raw_lock_type as u8,
+        )))
+    })?;
+
+    match lock_type {
+        AssetLockProofType::Instant => {
+            let instant: Ref<InstantAssetLockProofWasm> =
+                generic_of_js_val::<InstantAssetLockProofWasm>(js_value, "InstantAssetLockProof")?;
+
+            Ok(AssetLockProof::Instant(instant.clone().into()))
+        }
+        AssetLockProofType::Chain => {
+            let chain: Ref<ChainAssetLockProofWasm> =
+                generic_of_js_val::<ChainAssetLockProofWasm>(js_value, "ChainAssetLockProof")?;
+
+            Ok(AssetLockProof::Chain(chain.clone().into()))
+        }
+    }
+}
+
+#[wasm_bindgen(js_name=validateAssetLockTransaction)]
+pub async fn validate_asset_lock_transaction(
+    state_repository: ExternalStateRepositoryLike,
+    raw_transaction: String,
+    output_index: usize,
+    execution_context: &StateTransitionExecutionContextWasm,
+) -> Result<ValidationResultWasm, JsValue> {
+    let tx_bytes = Vec::from_hex(&raw_transaction)
+        .map_err(|_| RustConversionError::Error(String::from("invalid transaction hex")))?;
+
+    let state_repository_wrapper =
+        Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+    let validator = AssetLockTransactionValidator::new(state_repository_wrapper);
+
+    let result = validator
+        .validate(tx_bytes.as_slice(), output_index, execution_context.into())
+        .await
+        .map_err(|e| from_dpp_err(e.into()))?;
+
+    let validation_result = result.map(|item| {
+        let object = js_sys::Object::new();
+
+        js_sys::Reflect::set(
+            &object,
+            &"publicKeyHash".to_owned().into(),
+            &Buffer::from_bytes(&item.public_key_hash),
+        )
+        .unwrap();
+
+        let deserialized_tx = consensus::serialize(&item.transaction);
+
+        js_sys::Reflect::set(
+            &object,
+            &"transaction".to_owned().into(),
+            &Buffer::from_bytes(&deserialized_tx),
+        )
+        .unwrap();
+
+        object
+    });
+
+    Ok(validation_result.into())
+}
+
+#[wasm_bindgen(js_name=fetchAssetLockTransactionOutput)]
+pub async fn fetch_asset_lock_transaction_output(
+    state_repository: ExternalStateRepositoryLike,
+    raw_asset_lock_proof: JsValue,
+    execution_context: &StateTransitionExecutionContextWasm,
+) -> Result<JsValue, JsValue> {
+    let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&raw_asset_lock_proof)?;
+
+    let state_repository_wrapper =
+        Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+    let fetcher = AssetLockTransactionOutputFetcher::new(state_repository_wrapper);
+
+    let fetch_result = fetcher
+        .fetch(&asset_lock_proof, execution_context.into())
+        .await
+        .map_err(|e| from_dpp_error_ref(&e))?;
+
+    let tx_out = js_sys::Object::new();
+
+    js_sys::Reflect::set(
+        &tx_out,
+        &"satoshis".to_owned().into(),
+        &(fetch_result.value as u32).into(),
+    )
+    .unwrap();
+
+    let script_hex = format!("{:x}", fetch_result.script_pubkey);
+
+    js_sys::Reflect::set(&tx_out, &"script".to_owned().into(), &script_hex.into()).unwrap();
+
+    Ok(tx_out.into())
+}
+
+#[wasm_bindgen(js_name=fetchAssetLockPublicKeyHash)]
+pub async fn fetch_asset_lock_public_key_hash(
+    state_repository: ExternalStateRepositoryLike,
+    raw_asset_lock_proof: JsValue,
+    execution_context: &StateTransitionExecutionContextWasm,
+) -> Result<JsValue, JsValue> {
+    let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&raw_asset_lock_proof)?;
+
+    let state_repository_wrapper =
+        Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+    let tx_output_fetcher =
+        AssetLockTransactionOutputFetcher::new(state_repository_wrapper.clone());
+
+    let public_key_hash_fetcher =
+        AssetLockPublicKeyHashFetcher::new(state_repository_wrapper, tx_output_fetcher);
+
+    let fetch_result = public_key_hash_fetcher
+        .fetch_public_key_hash(asset_lock_proof, execution_context.into())
+        .await
+        .map_err(|e| from_dpp_error_ref(&e))?;
+
+    Ok(Buffer::from_bytes(&fetch_result).into())
+}

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

@@ -0,0 +1,26 @@
+use dpp::identity::state_transition::identity_create_transition::ApplyIdentityCreateTransition;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    IdentityCreateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=applyIdentityCreateTransition)]
+pub async fn apply_identity_create_transition_wasm(
+    state_repository: ExternalStateRepositoryLike,
+    state_transition: &IdentityCreateTransitionWasm,
+) -> Result<(), JsValue> {
+    let wrapped_state_repository =
+        Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+    let instance = ApplyIdentityCreateTransition::new(wrapped_state_repository);
+
+    instance
+        .apply_identity_create_transition(&state_transition.to_owned().into())
+        .await
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+    Ok(())
+}

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

@@ -0,0 +1,335 @@
+use std::convert::TryInto;
+use std::default::Default;
+
+use wasm_bindgen::__rt::Ref;
+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},
+        IdentityPublicKeyWasm,
+    },
+    state_transition::StateTransitionExecutionContextWasm,
+    with_js_error,
+};
+
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+use crate::utils::{generic_of_js_val, ToSerdeJSONExt};
+use dpp::{
+    identifier::Identifier,
+    identity::{
+        state_transition::{
+            asset_lock_proof::AssetLockProof, identity_create_transition::IdentityCreateTransition,
+        },
+        IdentityPublicKey,
+    },
+    state_transition::StateTransitionLike,
+    util::string_encoding,
+    util::string_encoding::Encoding,
+};
+
+#[wasm_bindgen(js_name=IdentityCreateTransition)]
+#[derive(Clone)]
+pub struct IdentityCreateTransitionWasm(IdentityCreateTransition);
+
+impl From<IdentityCreateTransition> for IdentityCreateTransitionWasm {
+    fn from(v: IdentityCreateTransition) -> Self {
+        IdentityCreateTransitionWasm(v)
+    }
+}
+
+impl From<IdentityCreateTransitionWasm> for IdentityCreateTransition {
+    fn from(v: IdentityCreateTransitionWasm) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen(js_class = IdentityCreateTransition)]
+impl IdentityCreateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<IdentityCreateTransitionWasm, JsValue> {
+        let raw_state_transition = raw_parameters.with_serde_to_json_value()?;
+
+        let identity_create_transition = IdentityCreateTransition::new(raw_state_transition)
+            .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
+
+        Ok(identity_create_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=setPublicKeys)]
+    pub fn set_public_keys(&mut self, public_keys: Vec<JsValue>) -> Result<(), JsValue> {
+        let public_keys = public_keys
+            .iter()
+            .map(|value| {
+                let public_key: Ref<IdentityPublicKeyWasm> =
+                    generic_of_js_val::<IdentityPublicKeyWasm>(value, "IdentityPublicKey")?;
+                Ok(public_key.clone().into())
+            })
+            .collect::<Result<Vec<IdentityPublicKey>, JsValue>>()?;
+
+        self.0.set_public_keys(public_keys);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=addPublicKeys)]
+    pub fn add_public_keys(&mut self, public_keys: Vec<JsValue>) -> Result<(), JsValue> {
+        let mut public_keys = public_keys
+            .iter()
+            .map(|value| {
+                let public_key: Ref<IdentityPublicKeyWasm> =
+                    generic_of_js_val::<IdentityPublicKeyWasm>(value, "IdentityPublicKey")?;
+                Ok(public_key.clone().into())
+            })
+            .collect::<Result<Vec<IdentityPublicKey>, JsValue>>()?;
+
+        self.0.add_public_keys(&mut public_keys);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeys)]
+    pub fn get_public_keys(&self) -> Vec<JsValue> {
+        self.0
+            .get_public_keys()
+            .iter()
+            .map(IdentityPublicKey::to_owned)
+            .map(IdentityPublicKeyWasm::from)
+            .map(JsValue::from)
+            .collect()
+    }
+
+    #[wasm_bindgen(getter, js_name=publicKeys)]
+    pub fn public_keys(&self) -> Vec<JsValue> {
+        self.get_public_keys()
+    }
+
+    #[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().clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.get_owner_id().clone().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 skip_signature = opts.skip_signature;
+        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).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,
+        )?;
+
+        let keys_objects = object
+            .public_keys
+            .into_iter()
+            .map(IdentityPublicKeyWasm::from)
+            .map(|key| key.to_object(skip_signature))
+            .collect::<Result<js_sys::Array, _>>()?;
+
+        js_sys::Reflect::set(&js_object, &"publicKeys".to_owned().into(), &keys_objects)?;
+
+        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 keys_objects = object
+            .public_keys
+            .into_iter()
+            .map(IdentityPublicKeyWasm::from)
+            .map(|key| key.to_json())
+            .collect::<Result<js_sys::Array, _>>()?;
+
+        js_sys::Reflect::set(&js_object, &"publicKeys".to_owned().into(), &keys_objects)?;
+
+        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.clone()).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())
+    }
+}