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

package/src/document/state_transition/document_batch_transition/document_transition/mod.rs

@@ -1,14 +1,274 @@
 mod document_create_transition;
 mod document_delete_transition;
-mod document_update_transition;
+mod document_replace_transition;
 
+use anyhow::Context;
 pub use document_create_transition::*;
 pub use document_delete_transition::*;
-pub use document_update_transition::*;
+pub use document_replace_transition::*;
 
-use dpp::prelude::DocumentTransition;
+use dpp::{
+    document::document_transition::{
+        DocumentCreateTransition, DocumentDeleteTransition, DocumentReplaceTransition,
+        DocumentTransitionExt, DocumentTransitionObjectLike,
+    },
+    prelude::{DocumentTransition, Identifier},
+    util::{json_schema::JsonSchemaExt, json_value::JsonValueExt},
+};
+use serde::Serialize;
+use serde_json::Value;
 use wasm_bindgen::prelude::*;
 
+use crate::{
+    buffer::Buffer,
+    identifier::{identifier_from_js_value, IdentifierWrapper},
+    lodash::lodash_set,
+    utils::{try_to_u64, Inner, ToSerdeJSONExt, WithJsError},
+    with_js_error, BinaryType, ConversionOptions, DataContractWasm,
+};
+
+#[wasm_bindgen(js_name=DocumentTransition)]
+#[derive(Debug, Clone)]
+pub struct DocumentTransitionWasm(DocumentTransition);
+
+#[wasm_bindgen(js_class=DocumentTransition)]
+impl DocumentTransitionWasm {
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> IdentifierWrapper {
+        self.0.get_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> String {
+        self.0.get_document_type().to_owned()
+    }
+
+    #[wasm_bindgen(js_name=getAction)]
+    pub fn get_action(&self) -> u8 {
+        self.0.get_action().into()
+    }
+
+    #[wasm_bindgen(js_name=getDataContract)]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.0.get_data_contract().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn get_data_contract_id(&self) -> IdentifierWrapper {
+        self.0.get_data_contract_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=setDataContractId)]
+    pub fn set_data_contract_id(&mut self, js_data_contract_id: &JsValue) -> Result<(), JsValue> {
+        let identifier = identifier_from_js_value(js_data_contract_id)?;
+        self.0.set_data_contract_id(identifier);
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getRevision)]
+    pub fn get_revision(&self) -> JsValue {
+        if let Some(revision) = self.0.get_revision() {
+            (revision as f64).into()
+        } else {
+            JsValue::NULL
+        }
+    }
+
+    #[wasm_bindgen(js_name=getCreatedAt)]
+    pub fn get_created_at(&self) -> JsValue {
+        if let Some(created_at) = self.0.get_created_at() {
+            (created_at as f64).into()
+        } else {
+            JsValue::NULL
+        }
+    }
+    #[wasm_bindgen(js_name=getUpdatedAt)]
+    pub fn get_updated_at(&self) -> JsValue {
+        if let Some(updated_at) = self.0.get_updated_at() {
+            (updated_at as f64).into()
+        } else {
+            JsValue::NULL
+        }
+    }
+
+    #[wasm_bindgen(js_name=setUpdatedAt)]
+    pub fn set_updated_at(&mut self, js_timestamp_millis: JsValue) -> Result<(), JsValue> {
+        if js_timestamp_millis.is_undefined() || js_timestamp_millis.is_null() {
+            self.0.set_updated_at(None);
+            return Ok(());
+        }
+        let timestamp_millis = try_to_u64(js_timestamp_millis)
+            .context("setting updatedAt in DocumentsBatchTransition")
+            .with_js_error()?;
+        self.0.set_updated_at(Some(timestamp_millis as i64));
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=setCreatedAt)]
+    pub fn set_created_at(&mut self, js_timestamp_millis: JsValue) -> Result<(), JsValue> {
+        if js_timestamp_millis.is_undefined() || js_timestamp_millis.is_null() {
+            self.0.set_created_at(None);
+            return Ok(());
+        }
+        let timestamp_millis = try_to_u64(js_timestamp_millis)
+            .context("setting createdAt in DocumentsBatchTransition")
+            .with_js_error()?;
+        self.0.set_created_at(Some(timestamp_millis as i64));
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getData)]
+    pub fn get_data(&self) -> Result<JsValue, JsValue> {
+        if let Some(data) = self.0.get_data() {
+            let (identifier_paths, binary_paths) = self
+                .0
+                .get_data_contract()
+                .get_identifiers_and_binary_paths(self.0.get_document_type())
+                .with_js_error()?;
+
+            let js_value = to_object(
+                data.to_owned(),
+                &JsValue::NULL,
+                identifier_paths,
+                binary_paths,
+            )?;
+            Ok(js_value)
+        } else {
+            Ok(JsValue::NULL)
+        }
+    }
+
+    #[wasm_bindgen(js_name=get)]
+    pub fn get(&self, path: &str) -> JsValue {
+        let binary_type = self.get_binary_type_of_path(path);
+
+        if let Some(value) = self.0.get_dynamic_property(path) {
+            match binary_type {
+                BinaryType::Identifier => {
+                    if let Ok(bytes) = serde_json::from_value::<Vec<u8>>(value.to_owned()) {
+                        let id: IdentifierWrapper = Identifier::from_bytes(&bytes).unwrap().into();
+
+                        return id.into();
+                    }
+                }
+                BinaryType::Buffer => {
+                    if let Ok(bytes) = serde_json::from_value::<Vec<u8>>(value.to_owned()) {
+                        return Buffer::from_bytes(&bytes).into();
+                    }
+                }
+                BinaryType::None => {
+                    let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+                    if let Ok(js_value) = value.serialize(&serializer) {
+                        return js_value;
+                    }
+                }
+            }
+        }
+
+        JsValue::undefined()
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, options: &JsValue) -> Result<JsValue, JsValue> {
+        match self.0 {
+            DocumentTransition::Create(ref t) => {
+                DocumentCreateTransitionWasm::from(t.to_owned()).to_object(options)
+            }
+            DocumentTransition::Replace(ref t) => {
+                DocumentReplaceTransitionWasm::from(t.to_owned()).to_object(options)
+            }
+            DocumentTransition::Delete(ref t) => {
+                DocumentDeleteTransitionWasm::from(t.to_owned()).to_object(options)
+            }
+        }
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let json_value = self.0.to_json().with_js_error()?;
+        with_js_error!(json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible()))
+    }
+
+    #[wasm_bindgen(js_name=fromTransitionCreate)]
+    pub fn from_transition_create(
+        js_create_transition: DocumentCreateTransitionWasm,
+    ) -> DocumentTransitionWasm {
+        let transition_create: DocumentCreateTransition = js_create_transition.into();
+        let document_transition = DocumentTransition::Create(transition_create);
+
+        document_transition.into()
+    }
+
+    #[wasm_bindgen(js_name=fromTransitionReplace)]
+    pub fn from_transition_replace(
+        js_replace_transition: DocumentReplaceTransitionWasm,
+    ) -> DocumentTransitionWasm {
+        let transition_replace: DocumentReplaceTransition = js_replace_transition.into();
+        let document_transition = DocumentTransition::Replace(transition_replace);
+
+        document_transition.into()
+    }
+
+    #[wasm_bindgen(js_name=fromTransitionDelete)]
+    pub fn from_transition_delete(
+        js_delete_transition: DocumentDeleteTransitionWasm,
+    ) -> DocumentTransitionWasm {
+        let transition_delete: DocumentDeleteTransition = js_delete_transition.into();
+        let document_transition = DocumentTransition::Delete(transition_delete);
+
+        document_transition.into()
+    }
+}
+
+impl DocumentTransitionWasm {
+    fn get_binary_type_of_path(&self, path: impl AsRef<str>) -> BinaryType {
+        let maybe_binary_properties = self
+            .0
+            .get_data_contract()
+            .get_binary_properties(self.0.get_document_type());
+
+        if let Ok(binary_properties) = maybe_binary_properties {
+            if let Some(data) = binary_properties.get(path.as_ref()) {
+                if data.is_type_of_identifier() {
+                    return BinaryType::Identifier;
+                }
+                return BinaryType::Buffer;
+            }
+        }
+        BinaryType::None
+    }
+}
+
+impl From<DocumentTransition> for DocumentTransitionWasm {
+    fn from(v: DocumentTransition) -> Self {
+        DocumentTransitionWasm(v)
+    }
+}
+
+impl From<DocumentTransitionWasm> for DocumentTransition {
+    fn from(v: DocumentTransitionWasm) -> Self {
+        v.0
+    }
+}
+
+impl Inner for DocumentTransitionWasm {
+    type InnerItem = DocumentTransition;
+
+    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
+    }
+}
+
 pub fn from_document_transition_to_js_value(document_transition: DocumentTransition) -> JsValue {
     match document_transition {
         DocumentTransition::Create(create_transition) => {
@@ -22,3 +282,42 @@ pub fn from_document_transition_to_js_value(document_transition: DocumentTransit
         }
     }
 }
+
+pub(crate) fn to_object<'a>(
+    value: Value,
+    options: &JsValue,
+    identifiers_paths: impl IntoIterator<Item = &'a str>,
+    binary_paths: impl IntoIterator<Item = &'a str>,
+) -> Result<JsValue, JsValue> {
+    let mut value = value;
+    let options: ConversionOptions = if options.is_object() {
+        let raw_options = options.with_serde_to_json_value()?;
+        serde_json::from_value(raw_options).with_js_error()?
+    } else {
+        Default::default()
+    };
+
+    let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+    let js_value = value.serialize(&serializer)?;
+
+    for path in identifiers_paths.into_iter() {
+        if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+            let buffer = Buffer::from_bytes(&bytes);
+            if !options.skip_identifiers_conversion {
+                lodash_set(&js_value, path, buffer.into());
+            } else {
+                let id = IdentifierWrapper::new(buffer.into())?;
+                lodash_set(&js_value, path, id.into());
+            }
+        }
+    }
+
+    for path in binary_paths.into_iter() {
+        if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+            let buffer = Buffer::from_bytes(&bytes);
+            lodash_set(&js_value, path, buffer.into());
+        }
+    }
+
+    Ok(js_value)
+}

package/src/document/state_transition/document_batch_transition/mod.rs

@@ -1 +1,379 @@
+use dpp::identity::KeyID;
+use dpp::{
+    document::{
+        document_transition::document_base_transition,
+        state_transition::documents_batch_transition::{self, property_names},
+        DocumentsBatchTransition,
+    },
+    prelude::{DataContract, DocumentTransition, Identifier},
+    state_transition::{
+        StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
+        StateTransitionType,
+    },
+    util::json_value::JsonValueExt,
+};
+use js_sys::{Array, Reflect};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    bls_adapter::{BlsAdapter, JsBlsAdapter},
+    buffer::Buffer,
+    document_batch_transition::document_transition::DocumentTransitionWasm,
+    identifier::IdentifierWrapper,
+    lodash::lodash_set,
+    utils::{
+        replace_identifiers_with_bytes_without_failing, Inner, IntoWasm, ToSerdeJSONExt,
+        WithJsError,
+    },
+    IdentityPublicKeyWasm, StateTransitionExecutionContextWasm,
+};
+pub mod apply_document_batch_transition;
 pub mod document_transition;
+pub mod validation;
+
+#[derive(Clone, Debug)]
+#[wasm_bindgen(js_name = DocumentsBatchTransition)]
+pub struct DocumentsBatchTransitionWasm(DocumentsBatchTransition);
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone, Copy)]
+#[serde(rename_all = "camelCase")]
+pub struct ToObjectOptions {
+    #[serde(default)]
+    skip_signature: bool,
+    #[serde(default)]
+    skip_identifiers_conversion: bool,
+}
+
+#[wasm_bindgen(js_class=DocumentsBatchTransition)]
+impl DocumentsBatchTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn from_raw_object(
+        js_raw_transition: JsValue,
+        data_contracts: Array,
+    ) -> Result<DocumentsBatchTransitionWasm, JsValue> {
+        let data_contracts_array_js = Array::from(&data_contracts);
+
+        let mut data_contracts: Vec<DataContract> = vec![];
+        for contract in data_contracts_array_js.iter() {
+            let json_value = contract.with_serde_to_json_value()?;
+            let data_contract = DataContract::from_json_object(json_value).with_js_error()?;
+            data_contracts.push(data_contract);
+        }
+
+        let mut batch_transition_value = js_raw_transition.with_serde_to_json_value()?;
+        replace_identifiers_with_bytes_without_failing(
+            &mut batch_transition_value,
+            DocumentsBatchTransition::identifiers_property_paths(),
+        );
+
+        if let Some(Value::Array(ref mut transitions)) =
+            batch_transition_value.get_mut(documents_batch_transition::property_names::TRANSITIONS)
+        {
+            for t in transitions {
+                replace_identifiers_with_bytes_without_failing(
+                    t,
+                    document_base_transition::IDENTIFIER_FIELDS,
+                );
+            }
+        }
+
+        let documents_batch_transition =
+            DocumentsBatchTransition::from_raw_object(batch_transition_value, data_contracts)
+                .with_js_error()?;
+
+        Ok(documents_batch_transition.into())
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        StateTransitionType::DocumentsBatch.into()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.get_owner_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getTransitions)]
+    pub fn get_transitions(&self) -> js_sys::Array {
+        let array = js_sys::Array::new();
+        let transitions = self.0.get_transitions();
+
+        for tr in transitions.iter().cloned() {
+            let transition: DocumentTransitionWasm = tr.into();
+            array.push(&transition.into());
+        }
+
+        array
+    }
+
+    #[wasm_bindgen(js_name=setTransitions)]
+    pub fn set_transitions(&mut self, js_transitions: Array) -> Result<(), JsValue> {
+        let mut transitions = vec![];
+        for js_transition in js_transitions.iter() {
+            let transition: DocumentTransition = js_transition
+                .to_wasm::<DocumentTransitionWasm>("DocumentTransition")?
+                .to_owned()
+                .into();
+            transitions.push(transition)
+        }
+
+        self.0.transitions = transitions;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let value = self.0.to_json(false).with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        let is_null_signature = value.get(property_names::SIGNATURE).is_none();
+        let is_null_signature_public_key_id =
+            value.get(property_names::SIGNATURE_PUBLIC_KEY_ID).is_none();
+
+        let js_value = value.serialize(&serializer)?;
+
+        if is_null_signature {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+        if is_null_signature_public_key_id {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE_PUBLIC_KEY_ID.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+
+        Ok(js_value)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, js_options: &JsValue) -> Result<JsValue, JsValue> {
+        let options: ToObjectOptions = if js_options.is_object() {
+            let raw_options = js_options.with_serde_to_json_value()?;
+            serde_json::from_value(raw_options).with_js_error()?
+        } else {
+            Default::default()
+        };
+
+        let mut value = self.0.to_object(options.skip_signature).with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let js_value = value.serialize(&serializer)?;
+        let is_signature_present = value.get(property_names::SIGNATURE).is_some();
+
+        // Transform every transition individually
+        let transitions = Array::new();
+        for transition in self.0.transitions.iter() {
+            let js_value =
+                DocumentTransitionWasm::from(transition.to_owned()).to_object(js_options)?;
+            transitions.push(&js_value);
+        }
+        // Replace the whole collection of transitions
+        Reflect::set(
+            &js_value,
+            &property_names::TRANSITIONS.into(),
+            &transitions.into(),
+        )?;
+
+        // Transform paths that are specific to the DocumentsBatchTransition
+        for path in DocumentsBatchTransition::binary_property_paths() {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let buffer = Buffer::from_bytes(&bytes);
+                lodash_set(&js_value, path, buffer.into());
+            }
+        }
+        for path in DocumentsBatchTransition::identifiers_property_paths() {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let buffer = Buffer::from_bytes(&bytes);
+                if !options.skip_identifiers_conversion {
+                    lodash_set(&js_value, path, buffer.into());
+                } else {
+                    let id = IdentifierWrapper::new(buffer.into())?;
+                    lodash_set(&js_value, path, id.into());
+                }
+            }
+        }
+
+        if !is_signature_present && !options.skip_signature {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+        if value.get(property_names::SIGNATURE_PUBLIC_KEY_ID).is_none() {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE_PUBLIC_KEY_ID.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+
+        Ok(js_value)
+    }
+
+    #[wasm_bindgen(js_name=getModifiedDataIds)]
+    pub fn get_modified_ids(&self) -> Array {
+        let array = Array::new();
+
+        for id in self.0.get_modified_data_ids() {
+            let id = <IdentifierWrapper as From<Identifier>>::from(id.to_owned());
+            array.push(&id.into());
+        }
+
+        array
+    }
+
+    // AbstractSTateTransitionIdentitySigned methods
+    #[wasm_bindgen(js_name=getSignaturePublicKeyId)]
+    pub fn get_signature_public_key_id(&self) -> Option<f64> {
+        self.0.get_signature_public_key_id().map(|v| v as f64)
+    }
+
+    #[wasm_bindgen(js_name=sign)]
+    pub fn sign(
+        &mut self,
+        identity_public_key: &IdentityPublicKeyWasm,
+        private_key: &[u8],
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        self.0
+            .sign(
+                &identity_public_key.to_owned().into(),
+                private_key,
+                &BlsAdapter(bls),
+            )
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=verifyPublicKeyLevelAndPurpose)]
+    pub fn verify_public_key_level_and_purpose(
+        &self,
+        public_key: &IdentityPublicKeyWasm,
+    ) -> Result<(), JsValue> {
+        self.0
+            .verify_public_key_level_and_purpose(public_key.inner())
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=verifyPublicKeyIsEnabled)]
+    pub fn verify_public_key_is_enabled(
+        &self,
+        public_key: &IdentityPublicKeyWasm,
+    ) -> Result<(), JsValue> {
+        self.0
+            .verify_public_key_is_enabled(public_key.inner())
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=verifySignature)]
+    pub fn verify_signature(
+        &self,
+        public_key: &IdentityPublicKeyWasm,
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        self.0
+            .verify_signature(public_key.inner(), &BlsAdapter(bls))
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=setSignaturePublicKey)]
+    pub fn set_signature_public_key(&mut self, key_id: KeyID) {
+        self.0.set_signature_public_key_id(key_id)
+    }
+
+    #[wasm_bindgen(js_name=getKeySecurityLevelRequirement)]
+    pub fn get_security_level_requirement(&self) -> u8 {
+        self.0.get_security_level_requirement() as u8
+    }
+
+    // AbstractStateTransition methods
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.get_protocol_version()
+    }
+
+    #[wasm_bindgen(js_name=getSignature)]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.get_signature().to_owned()
+    }
+
+    #[wasm_bindgen(js_name=setSignature)]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature(signature)
+    }
+
+    #[wasm_bindgen(js_name=calculateFee)]
+    pub fn calculate_fee(&self) -> i64 {
+        self.0.calculate_fee()
+    }
+
+    #[wasm_bindgen(js_name=isDocumentStateTransition)]
+    pub fn is_document_state_transition(&self) -> bool {
+        self.0.is_document_state_transition()
+    }
+
+    #[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=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().clone().into()
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self, options: &JsValue) -> Result<Buffer, JsValue> {
+        let skip_signature = if options.is_object() {
+            let options = options.with_serde_to_json_value()?;
+            options.get_bool("skipSignature").unwrap_or_default()
+        } else {
+            false
+        };
+        let bytes = self.0.to_buffer(skip_signature).with_js_error()?;
+
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self, options: JsValue) -> Result<Buffer, JsValue> {
+        let skip_signature = if options.is_object() {
+            let options = options.with_serde_to_json_value()?;
+            options.get_bool("skipSignature").unwrap_or_default()
+        } else {
+            false
+        };
+        let bytes = self.0.hash(skip_signature).with_js_error()?;
+
+        Ok(Buffer::from_bytes(&bytes))
+    }
+}
+
+impl From<DocumentsBatchTransition> for DocumentsBatchTransitionWasm {
+    fn from(t: DocumentsBatchTransition) -> Self {
+        DocumentsBatchTransitionWasm(t)
+    }
+}
+
+impl From<DocumentsBatchTransitionWasm> for DocumentsBatchTransition {
+    fn from(t: DocumentsBatchTransitionWasm) -> Self {
+        t.0
+    }
+}