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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.25.0-dev.12",
+  "version": "0.25.0-dev.14",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,8 +44,8 @@
     "@babel/core": "^7.15.5",
     "@babel/preset-env": "^7.15.4",
     "@dashevo/dashcore-lib": "~0.20.6",
-    "@dashevo/dpns-contract": "0.25.0-dev.12",
-    "@dashevo/dpp": "0.25.0-dev.12",
+    "@dashevo/dpns-contract": "0.25.0-dev.14",
+    "@dashevo/dpp": "0.25.0-dev.14",
     "@dashevo/wasm-re2": "~1.0.2",
     "@types/bs58": "^4.0.1",
     "@types/node": "^14.6.0",

package/scripts/build-wasm.sh

@@ -1,46 +1,50 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC2312
+set -ex
 
 TARGET=wasm32-unknown-unknown
 
-PROFILE_ARG=""
-PROFILE="debug"
-
-if [ -n "$CARGO_BUILD_PROFILE" ]; then
-    if [ "$CARGO_BUILD_PROFILE" == "release" ]; then
-      PROFILE_ARG="--release"
-      PROFILE="release"
-    elif [ "$CARGO_BUILD_PROFILE" != "debug" ]; then
-      PROFILE_ARG="--profile $CARGO_BUILD_PROFILE"
-      PROFILE="$CARGO_BUILD_PROFILE"
-    fi
+# "--profile release" is equivalent of "--release", see
+# https://github.com/rust-lang/cargo/blob/13413c64ff88dd6c2824e9eb9374fc5f10895d28/src/cargo/util/command_prelude.rs#L426
+CARGO_BUILD_PROFILE="${CARGO_BUILD_PROFILE:-dev}"
+PROFILE_ARG="--profile ${CARGO_BUILD_PROFILE}"
+PROFILE="${CARGO_BUILD_PROFILE}"
+if [[ "${CARGO_BUILD_PROFILE}" == "dev" ]]; then
+  PROFILE=debug
 fi
 
-OUTPUT_DIR="$PWD/wasm"
-OUTPUT_FILE="$OUTPUT_DIR/wasm_dpp_bg.wasm"
-BUILD_COMMAND="cargo build --config net.git-fetch-with-cli=true --target=$TARGET $PROFILE_ARG"
-BINDGEN_COMMAND="wasm-bindgen --out-dir=$OUTPUT_DIR --target=web --omit-default-module-path ../../target/$TARGET/$PROFILE/wasm_dpp.wasm"
+OUTPUT_DIR="${PWD}/wasm"
+WORKSPACE_ROOT="$(dirname "$0")/../../.."
+# shellcheck disable=SC2034
+OUTPUT_FILE="${OUTPUT_DIR}/wasm_dpp_bg.wasm"
+BUILD_COMMAND="cargo build --config net.git-fetch-with-cli=true --target=${TARGET} ${PROFILE_ARG}"
+BINDGEN_COMMAND="wasm-bindgen --out-dir=${OUTPUT_DIR} --target=web --omit-default-module-path ../../target/${TARGET}/${PROFILE}/wasm_dpp.wasm"
 
-
-if ! [[ -d $OUTPUT_DIR ]];  then
-  mkdir -p "$OUTPUT_DIR"
+if ! [[ -d ${OUTPUT_DIR} ]]; then
+  mkdir -p "${OUTPUT_DIR}"
 fi
 
-if ! [ -x "$(command -v wasm-bindgen)" ]; then
-    echo 'Wasm-bindgen CLI is not installed. Installing';
-    cargo install -f wasm-bindgen-cli
+if ! [[ -x "$(command -v cargo-lock)" ]]; then
+  echo 'cargo-lock is not installed. Installing'
+  cargo install cargo-lock --features=cli --profile "${CARGO_BUILD_PROFILE}"
 fi
 
+WASM_BINDGEN_VERSION=$(cargo-lock list --file "${WORKSPACE_ROOT}/Cargo.lock" --package wasm-bindgen | grep -Eo '[0-9.]+')
+if ! [[ "$(wasm-bindgen --version)" =~ ${WASM_BINDGEN_VERSION} ]]; then
+  echo "Wasm-bindgen CLI ${WASM_BINDGEN_VERSION} is not installed. Installing"
+  cargo install --config net.git-fetch-with-cli=true --profile "${CARGO_BUILD_PROFILE}" -f "wasm-bindgen-cli@${WASM_BINDGEN_VERSION}"
+fi
 
 # On a mac, bundled clang won't work - you need to install LLVM manually through brew,
 # and then set the correct env for the build to work
-if [[ "$OSTYPE" == "darwin"* ]]; then
-    AR_PATH=$(which llvm-ar)
-    CLANG_PATH=$(which clang)
-    AR=$AR_PATH CC=$CLANG_PATH $BUILD_COMMAND
-    AR=$AR_PATH CC=$CLANG_PATH $BINDGEN_COMMAND
+if [[ "${OSTYPE}" == "darwin"* ]]; then
+  AR_PATH=$(command -v llvm-ar)
+  CLANG_PATH=$(command -v clang)
+  AR=${AR_PATH} CC=${CLANG_PATH} ${BUILD_COMMAND}
+  AR=${AR_PATH} CC=${CLANG_PATH} ${BINDGEN_COMMAND}
 else
-    $BUILD_COMMAND
-    $BINDGEN_COMMAND
+  ${BUILD_COMMAND}
+  ${BINDGEN_COMMAND}
 fi
 
 # EMCC_CFLAGS="-s ERROR_ON_UNDEFINED_SYMBOLS=0 --no-entry" cargo build --target=wasm32-unknown-emscripten --release

package/src/data_contract/data_contract.rs

@@ -1,45 +1,77 @@
 #![allow(clippy::from_over_into)]
 
 use std::collections::BTreeMap;
-use std::convert::{TryFrom, TryInto};
+use std::convert::TryFrom;
 
 pub use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
 use wasm_bindgen::prelude::*;
 
-use dpp::data_contract::{DataContract, SCHEMA_URI};
+use dpp::data_contract::{CreatedDataContract, DataContract, SCHEMA_URI};
 use dpp::platform_value::string_encoding::Encoding;
 use dpp::platform_value::{Bytes32, Value};
 
 use dpp::serialization_traits::PlatformSerializable;
-use dpp::{platform_value, Convertible};
+use dpp::{platform_value, Convertible, ProtocolError};
 
-use crate::errors::RustConversionError;
 use crate::identifier::identifier_from_js_value;
 use crate::metadata::MetadataWasm;
-use crate::utils::{IntoWasm, WithJsError};
+use crate::utils::{Inner, IntoWasm, WithJsError};
 use crate::{bail_js, with_js_error};
 use crate::{buffer::Buffer, identifier::IdentifierWrapper};
 
 #[wasm_bindgen(js_name=DataContract)]
 #[derive(Debug, Clone)]
-pub struct DataContractWasm(pub(crate) DataContract);
+pub struct DataContractWasm {
+    inner: DataContract,
+    entropy_used: Option<Vec<u8>>,
+}
 
+/// CreatedDataContract contains entropy and is used to create
+/// DataContractCreateTransition
+impl std::convert::From<CreatedDataContract> for DataContractWasm {
+    fn from(v: CreatedDataContract) -> Self {
+        DataContractWasm {
+            inner: v.data_contract,
+            entropy_used: Some(v.entropy_used.to_vec()),
+        }
+    }
+}
+
+/// Regular DataContract does not contain entropy and is used
+/// in DataContractUpdateTransition
 impl std::convert::From<DataContract> for DataContractWasm {
     fn from(v: DataContract) -> Self {
-        DataContractWasm(v)
+        DataContractWasm {
+            inner: v,
+            entropy_used: None,
+        }
     }
 }
 
 impl std::convert::From<&DataContractWasm> for DataContract {
     fn from(v: &DataContractWasm) -> Self {
-        v.0.clone()
+        v.inner.clone()
+    }
+}
+
+impl std::convert::TryFrom<&DataContractWasm> for CreatedDataContract {
+    type Error = ProtocolError;
+    fn try_from(v: &DataContractWasm) -> Result<Self, Self::Error> {
+        Ok(Self {
+            data_contract: v.to_owned().into(),
+            entropy_used: if let Some(entropy_used) = &v.entropy_used {
+                Bytes32::from_vec(entropy_used.to_owned())?
+            } else {
+                Bytes32::default()
+            },
+        })
     }
 }
 
 impl std::convert::Into<DataContract> for DataContractWasm {
     fn into(self) -> DataContract {
-        self.0
+        self.inner
     }
 }
 
@@ -96,54 +128,54 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=getProtocolVersion)]
     pub fn get_protocol_version(&self) -> u32 {
-        self.0.protocol_version
+        self.inner.protocol_version
     }
 
     #[wasm_bindgen(js_name=getId)]
     pub fn get_id(&self) -> IdentifierWrapper {
-        self.0.id.into()
+        self.inner.id.into()
     }
 
     #[wasm_bindgen(js_name=setId)]
     pub fn set_id(&mut self, id: &JsValue) -> Result<(), JsValue> {
         let id = identifier_from_js_value(id)?;
-        self.0.id = id;
+        self.inner.id = id;
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
-        self.0.owner_id.into()
+        self.inner.owner_id.into()
     }
 
     #[wasm_bindgen(js_name=getVersion)]
     pub fn get_version(&self) -> u32 {
-        self.0.version
+        self.inner.version
     }
 
     #[wasm_bindgen(js_name=setVersion)]
     pub fn set_version(&mut self, v: u32) {
-        self.0.version = v;
+        self.inner.version = v;
     }
 
     #[wasm_bindgen(js_name=incrementVersion)]
     pub fn increment_version(&mut self) {
-        self.0.increment_version()
+        self.inner.increment_version()
     }
 
     #[wasm_bindgen(js_name=getJsonSchemaId)]
     pub fn get_json_schema_id(&self) -> String {
-        self.0.id.to_string(Encoding::Base58)
+        self.inner.id.to_string(Encoding::Base58)
     }
 
     #[wasm_bindgen(js_name=setJsonMetaSchema)]
     pub fn set_json_meta_schema(&mut self, schema: String) {
-        self.0.schema = schema;
+        self.inner.schema = schema;
     }
 
     #[wasm_bindgen(js_name=getJsonMetaSchema)]
     pub fn get_json_meta_schema(&self) -> String {
-        self.0.schema.clone()
+        self.inner.schema.clone()
     }
     #[wasm_bindgen(js_name=setDocuments)]
     pub fn set_documents(&mut self, documents: JsValue) -> Result<(), JsValue> {
@@ -157,7 +189,7 @@ impl DataContractWasm {
                 }
                 docs.insert(k, v);
             }
-            self.0.documents = docs;
+            self.inner.documents = docs;
         } else {
             bail_js!("the parameter 'documents' is not an JS object")
         }
@@ -167,12 +199,12 @@ impl DataContractWasm {
     #[wasm_bindgen(js_name=getDocuments)]
     pub fn get_documents(&self) -> Result<JsValue, JsValue> {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(self.0.documents.serialize(&serializer))
+        with_js_error!(self.inner.documents.serialize(&serializer))
     }
 
     #[wasm_bindgen(js_name=isDocumentDefined)]
     pub fn is_document_defined(&self, doc_type: String) -> bool {
-        self.0.is_document_defined(&doc_type)
+        self.inner.is_document_defined(&doc_type)
     }
 
     #[wasm_bindgen(js_name=setDocumentSchema)]
@@ -182,7 +214,7 @@ impl DataContractWasm {
         schema: JsValue,
     ) -> Result<(), JsValue> {
         let json_schema: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(schema))?;
-        self.0
+        self.inner
             .set_document_schema(doc_type, json_schema)
             .with_js_error()?;
         Ok(())
@@ -190,7 +222,7 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=getDocumentSchema)]
     pub fn get_document_schema(&mut self, doc_type: &str) -> Result<JsValue, JsValue> {
-        let doc_schema = self.0.get_document_schema(doc_type).with_js_error()?;
+        let doc_schema = self.inner.get_document_schema(doc_type).with_js_error()?;
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         with_js_error!(doc_schema.serialize(&serializer))
     }
@@ -198,7 +230,10 @@ impl DataContractWasm {
     #[wasm_bindgen(js_name=getDocumentSchemaRef)]
     pub fn get_document_schema_ref(&self, doc_type: &str) -> Result<JsValue, JsValue> {
         with_js_error!(serde_wasm_bindgen::to_value(
-            &self.0.get_document_schema_ref(doc_type).with_js_error()?
+            &self
+                .inner
+                .get_document_schema_ref(doc_type)
+                .with_js_error()?
         ))
     }
 
@@ -217,7 +252,7 @@ impl DataContractWasm {
             if definitions.is_empty() {
                 bail_js!("`definitions` cannot be empty");
             }
-            self.0.defs = Some(definitions);
+            self.inner.defs = Some(definitions);
         } else {
             bail_js!("the parameter 'definitions' is not an JS object");
         }
@@ -227,31 +262,28 @@ impl DataContractWasm {
     #[wasm_bindgen(js_name=getDefinitions)]
     pub fn get_definitions(&self) -> Result<JsValue, JsValue> {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(self.0.defs.serialize(&serializer))
+        with_js_error!(self.inner.defs.serialize(&serializer))
     }
 
     #[wasm_bindgen(js_name=setEntropy)]
     pub fn set_entropy(&mut self, e: Vec<u8>) -> Result<(), JsValue> {
-        let entropy: [u8; 32] = e.try_into().map_err(|_| {
-            RustConversionError::Error(String::from(
-                "unable to turn the data into 32 bytes array of bytes",
-            ))
-            .to_js_value()
-        })?;
-        self.0.entropy = Bytes32::new(entropy);
+        self.entropy_used = Some(e);
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getEntropy)]
-    pub fn get_entropy(&mut self) -> Buffer {
-        Buffer::from_bytes_owned(self.0.entropy.to_vec())
+    pub fn get_entropy(&mut self) -> JsValue {
+        self.entropy_used
+            .as_ref()
+            .map(|e| Buffer::from_bytes(e.as_slice()).into())
+            .unwrap_or(JsValue::undefined())
     }
 
     #[wasm_bindgen(js_name=getBinaryProperties)]
     pub fn get_binary_properties(&self, doc_type: &str) -> Result<JsValue, JsValue> {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         with_js_error!(self
-            .0
+            .inner
             .get_binary_properties(doc_type)
             .with_js_error()?
             .serialize(&serializer))
@@ -259,12 +291,12 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=getMetadata)]
     pub fn get_metadata(&self) -> Option<MetadataWasm> {
-        self.0.metadata.clone().map(Into::into)
+        self.inner.metadata.clone().map(Into::into)
     }
 
     #[wasm_bindgen(js_name=setMetadata)]
     pub fn set_metadata(&mut self, metadata: JsValue) -> Result<(), JsValue> {
-        self.0.metadata = if !metadata.is_falsy() {
+        self.inner.metadata = if !metadata.is_falsy() {
             let metadata = metadata.to_wasm::<MetadataWasm>("Metadata")?;
             Some(metadata.to_owned().into())
         } else {
@@ -276,20 +308,20 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self) -> Result<JsValue, JsValue> {
-        let value = self.0.to_cleaned_object().with_js_error()?;
+        let value = self.inner.to_cleaned_object().with_js_error()?;
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         let object = with_js_error!(value.serialize(&serializer))?;
 
         js_sys::Reflect::set(
             &object,
             &Into::<JsValue>::into("$id".to_owned()),
-            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.0.id.to_vec())),
+            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.inner.id.to_vec())),
         )
         .expect("target is an object");
         js_sys::Reflect::set(
             &object,
             &Into::<JsValue>::into("ownerId".to_owned()),
-            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.0.owner_id.to_vec())),
+            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.inner.owner_id.to_vec())),
         )
         .expect("target is an object");
         Ok(object)
@@ -297,20 +329,20 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let json = self.0.to_json().with_js_error()?;
+        let json = self.inner.to_json().with_js_error()?;
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         with_js_error!(json.serialize(&serializer))
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes = PlatformSerializable::serialize(&self.0).with_js_error()?;
+        let bytes = PlatformSerializable::serialize(&self.inner).with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=hash)]
     pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
-        self.0.hash().with_js_error()
+        self.inner.hash().with_js_error()
     }
 
     #[wasm_bindgen(js_name=from)]
@@ -333,6 +365,28 @@ impl DataContractWasm {
     }
 }
 
+impl Inner for DataContractWasm {
+    type InnerItem = DataContract;
+
+    fn into_inner(self) -> DataContract {
+        self.inner
+    }
+
+    fn inner(&self) -> &DataContract {
+        &self.inner
+    }
+
+    fn inner_mut(&mut self) -> &mut DataContract {
+        &mut self.inner
+    }
+}
+
+impl DataContractWasm {
+    pub fn inner(&self) -> &DataContract {
+        &self.inner
+    }
+}
+
 #[wasm_bindgen(js_name=DataContractDefaults)]
 pub struct DataContractDefaults;
 
@@ -343,12 +397,3 @@ impl DataContractDefaults {
         SCHEMA_URI.to_string()
     }
 }
-
-impl DataContractWasm {
-    pub fn inner(&self) -> &DataContract {
-        &self.0
-    }
-}
-
-#[test]
-fn test_query_many() {}

package/src/data_contract/data_contract_facade.rs

@@ -1,10 +1,11 @@
 use crate::errors::protocol_error::from_protocol_error;
+use std::convert::TryFrom;
 
 use crate::{
     js_value_to_data_contract_value, DataContractCreateTransitionWasm,
     DataContractUpdateTransitionWasm, DataContractWasm,
 };
-use dpp::data_contract::{DataContract, DataContractFacade};
+use dpp::data_contract::{CreatedDataContract, DataContract, DataContractFacade};
 use dpp::identifier::Identifier;
 use dpp::version::ProtocolVersionValidator;
 
@@ -114,7 +115,9 @@ impl DataContractFacadeWasm {
         data_contract: &DataContractWasm,
     ) -> Result<DataContractCreateTransitionWasm, JsValue> {
         self.0
-            .create_data_contract_create_transition(data_contract.clone().into())
+            .create_data_contract_create_transition(
+                CreatedDataContract::try_from(data_contract).with_js_error()?,
+            )
             .map(DataContractCreateTransitionWasm::from)
             .with_js_error()
     }

package/src/data_contract/state_transition/data_contract_update_transition/mod.rs

@@ -84,11 +84,6 @@ impl DataContractUpdateTransitionWasm {
         self.0.protocol_version
     }
 
-    #[wasm_bindgen(js_name=getEntropy)]
-    pub fn get_entropy(&self) -> Buffer {
-        Buffer::from_bytes_owned(self.0.data_contract.entropy.to_vec())
-    }
-
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
         (*self.0.get_owner_id()).into()

package/src/data_contract_factory/data_contract_factory.rs

@@ -1,5 +1,7 @@
+use std::convert::TryFrom;
 use std::sync::Arc;
 
+use dpp::data_contract::CreatedDataContract;
 use dpp::{
     data_contract::{
         validation::data_contract_validator::DataContractValidator, DataContractFactory,
@@ -156,7 +158,9 @@ impl DataContractFactoryWasm {
         data_contract: &DataContractWasm,
     ) -> Result<DataContractCreateTransitionWasm, JsValue> {
         self.0
-            .create_data_contract_create_transition(data_contract.clone().into())
+            .create_data_contract_create_transition(
+                CreatedDataContract::try_from(data_contract).with_js_error()?,
+            )
             .map(Into::into)
             .with_js_error()
     }

package/src/document/document_facade.rs

@@ -89,6 +89,18 @@ impl DocumentFacadeWasm {
             .await
     }
 
+    // TODO(rs-drive-abci): add tests
+    #[wasm_bindgen(js_name=createExtendedDocumentFromDocumentBuffer)]
+    pub fn create_extended_from_document_buffer(
+        &self,
+        buffer: Vec<u8>,
+        document_type: &str,
+        data_contract: &DataContractWasm,
+    ) -> Result<ExtendedDocumentWasm, JsValue> {
+        self.factory
+            .create_extended_from_document_buffer(buffer, document_type, data_contract)
+    }
+
     /// Creates Documents State Transition
     #[wasm_bindgen(js_name=createStateTransition)]
     pub fn create_state_transition(

package/src/document/factory.rs

@@ -212,6 +212,23 @@ impl DocumentFactoryWASM {
 
         Ok(document.into())
     }
+
+    #[wasm_bindgen(js_name=createExtendedDocumentFromDocumentBuffer)]
+    pub fn create_extended_from_document_buffer(
+        &self,
+        buffer: Vec<u8>,
+        document_type: &str,
+        data_contract: &DataContractWasm,
+    ) -> Result<ExtendedDocumentWasm, JsValue> {
+        self.0
+            .create_extended_from_document_buffer(
+                buffer.as_slice(),
+                document_type,
+                &data_contract.to_owned().into(),
+            )
+            .map(|document| document.into())
+            .with_js_error()
+    }
 }
 
 fn extract_documents_by_action(

package/src/document/mod.rs

@@ -238,7 +238,7 @@ impl DocumentWasm {
         let mut value = self.0.to_object().with_js_error()?;
 
         let (identifiers_paths, binary_paths) =
-            Document::get_identifiers_and_binary_paths(&data_contract.0, document_type_name)
+            Document::get_identifiers_and_binary_paths(data_contract.inner(), document_type_name)
                 .with_js_error()?;
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         let js_value = value.serialize(&serializer)?;
@@ -287,12 +287,12 @@ impl DocumentWasm {
         document_type_name: String,
     ) -> Result<Buffer, JsValue> {
         let document_type = data_contract
-            .0
+            .inner()
             .document_type_for_name(document_type_name.as_str())
             .with_js_error()?;
         let bytes = self
             .0
-            .hash(&data_contract.0, document_type)
+            .hash(data_contract.inner(), document_type)
             .with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
@@ -311,7 +311,7 @@ impl DocumentWasm {
         document_type_name: String,
     ) -> BinaryType {
         let maybe_binary_properties = data_contract
-            .0
+            .inner()
             .get_binary_properties(document_type_name.as_str());
 
         if let Ok(binary_properties) = maybe_binary_properties {

package/src/errors/consensus/consensus_error.rs

@@ -115,6 +115,8 @@ use crate::errors::consensus::fee::BalanceIsNotEnoughErrorWasm;
 use crate::errors::consensus::state::data_contract::data_trigger::DataTriggerInvalidResultErrorWasm;
 use crate::errors::consensus::value_error::ValueErrorWasm;
 
+use super::state::document::DocumentTimestampsAreEqualErrorWasm;
+
 pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue {
     match e {
         DPPConsensusError::FeeError(e) => match e {
@@ -197,6 +199,9 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
             let wasm_error: IdentityInsufficientBalanceErrorWasm = e.into();
             wasm_error.into()
         }
+        StateError::DocumentTimestampsAreEqualError(e) => {
+            DocumentTimestampsAreEqualErrorWasm::from(e).into()
+        }
     }
 }
 

package/src/errors/consensus/state/document/document_timestamps_are_equal_error.rs

@@ -0,0 +1,42 @@
+use crate::buffer::Buffer;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::state::document::document_timestamps_are_equal_error::DocumentTimestampsAreEqualError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentTimestampsAreEqualError)]
+pub struct DocumentTimestampsAreEqualErrorWasm {
+    inner: DocumentTimestampsAreEqualError,
+}
+
+impl From<&DocumentTimestampsAreEqualError> for DocumentTimestampsAreEqualErrorWasm {
+    fn from(e: &DocumentTimestampsAreEqualError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+#[wasm_bindgen(js_class=DocumentTimestampsAreEqualError)]
+impl DocumentTimestampsAreEqualErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.inner.document_id().as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+
+    #[wasm_bindgen(js_name=serialize)]
+    pub fn serialize(&self) -> Result<Buffer, JsError> {
+        let bytes = ConsensusError::from(self.inner.clone())
+            .serialize()
+            .map_err(|e| JsError::from(e))?;
+
+        Ok(Buffer::from_bytes(bytes.as_slice()))
+    }
+}

package/src/errors/consensus/state/document/mod.rs

@@ -2,6 +2,7 @@ mod document_already_present_error;
 mod document_not_found_error;
 mod document_owner_id_mismatch_error;
 mod document_timestamp_window_violation_error;
+mod document_timestamps_are_equal_error;
 mod document_timestamps_mismatch_error;
 mod duplicate_unique_index_error;
 mod invalid_document_revision_error;
@@ -10,6 +11,7 @@ pub use document_already_present_error::*;
 pub use document_not_found_error::*;
 pub use document_owner_id_mismatch_error::*;
 pub use document_timestamp_window_violation_error::*;
+pub use document_timestamps_are_equal_error::*;
 pub use document_timestamps_mismatch_error::*;
 pub use duplicate_unique_index_error::*;
 pub use invalid_document_revision_error::*;