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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.24.0-dev.10",
+  "version": "0.24.0-dev.11",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,8 +35,8 @@
   "devDependencies": {
     "@apidevtools/json-schema-ref-parser": "^8.0.0",
     "@dashevo/dashcore-lib": "~0.19.44",
-    "@dashevo/dpns-contract": "0.24.0-dev.10",
-    "@dashevo/dpp": "0.24.0-dev.10",
+    "@dashevo/dpns-contract": "0.24.0-dev.11",
+    "@dashevo/dpp": "0.24.0-dev.11",
     "@dashevo/wasm-re2": "~1.0.2",
     "@types/node": "^14.6.0",
     "ajv": "^8.6.0",

package/src/data_contract/state_transition/data_contract_create_transition/apply.rs

@@ -0,0 +1,44 @@
+use std::ops::Deref;
+
+use dpp::data_contract::state_transition::apply_data_contract_create_transition_factory::ApplyDataContractCreateTransition;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    DataContractCreateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=ApplyDataContractCreateTransition)]
+pub struct ApplyDataContractCreateTransitionWasm(
+    ApplyDataContractCreateTransition<ExternalStateRepositoryLikeWrapper>,
+);
+
+impl From<ApplyDataContractCreateTransition<ExternalStateRepositoryLikeWrapper>>
+    for ApplyDataContractCreateTransitionWasm
+{
+    fn from(wa: ApplyDataContractCreateTransition<ExternalStateRepositoryLikeWrapper>) -> Self {
+        ApplyDataContractCreateTransitionWasm(wa)
+    }
+}
+
+#[wasm_bindgen(js_class=ApplyDataContractCreateTransition)]
+impl ApplyDataContractCreateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> ApplyDataContractCreateTransitionWasm {
+        let pinned_js_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+        ApplyDataContractCreateTransition::new(pinned_js_state_repository).into()
+    }
+
+    #[wasm_bindgen(js_name=applyDataContractCreateTransition)]
+    pub async fn apply_data_contract_create_transition(
+        &self,
+        transition: DataContractCreateTransitionWasm,
+    ) -> Result<(), JsError> {
+        self.0
+            .apply_data_contract_create_transition(&transition.into())
+            .await
+            .map_err(|e| e.deref().into())
+    }
+}

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

@@ -1,7 +1,24 @@
-use dpp::data_contract::state_transition::DataContractCreateTransition;
+mod apply;
+mod validation;
+
+pub use apply::*;
+pub use validation::*;
+
+use dpp::{
+    data_contract::state_transition::DataContractCreateTransition,
+    state_transition::{
+        StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
+    },
+};
+use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
-use crate::{buffer::Buffer, DataContractWasm};
+use crate::{
+    buffer::Buffer,
+    errors::{from_dpp_err, RustConversionError},
+    identifier::IdentifierWrapper,
+    with_js_error, DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
+};
 
 #[wasm_bindgen(js_name=DataContractCreateTransition)]
 pub struct DataContractCreateTransitionWasm(DataContractCreateTransition);
@@ -18,8 +35,33 @@ impl Into<DataContractCreateTransition> for DataContractCreateTransitionWasm {
     }
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DataContractCreateTransitionParameters {
+    protocol_version: u32,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    data_contract: Option<DataContractParameters>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    entropy: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    signature_public_key_id: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    signature: Option<Vec<u8>>,
+}
+
 #[wasm_bindgen(js_class=DataContractCreateTransition)]
 impl DataContractCreateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<DataContractCreateTransitionWasm, JsValue> {
+        let parameters: DataContractCreateTransitionParameters =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+        DataContractCreateTransition::from_raw_object(
+            serde_json::to_value(parameters).expect("the struct will be a valid json"),
+        )
+        .map(Into::into)
+        .map_err(from_dpp_err)
+    }
+
     #[wasm_bindgen(js_name=getDataContract)]
     pub fn get_data_contract(&self) -> DataContractWasm {
         self.0.data_contract.clone().into()
@@ -34,4 +76,63 @@ impl DataContractCreateTransitionWasm {
     pub fn get_entropy(&self) -> Buffer {
         Buffer::from_bytes(&self.0.entropy)
     }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.get_owner_id().clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u32 {
+        self.0.get_type() as u32
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        Ok(self
+            .0
+            .to_json(skip_signature.unwrap_or(false))
+            .map_err(from_dpp_err)?
+            .serialize(&serializer)
+            .expect("JSON is a valid object"))
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self, skip_signature: Option<bool>) -> Result<Buffer, JsValue> {
+        let bytes = self
+            .0
+            .to_buffer(skip_signature.unwrap_or(false))
+            .map_err(from_dpp_err)?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=getModifiedDataIds)]
+    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
+        self.0
+            .get_modified_data_ids()
+            .into_iter()
+            .map(|identifier| Into::<IdentifierWrapper>::into(identifier.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())
+    }
 }

package/src/data_contract/state_transition/data_contract_create_transition/validation.rs

@@ -0,0 +1,24 @@
+use dpp::data_contract::state_transition::data_contract_create_transition::validation::state::validate_data_contract_create_transition_state::validate_data_contract_create_transition_state as dpp_validate_data_contract_create_transition_state;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    errors::from_dpp_err,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation_result::ValidationResultWasm,
+    DataContractCreateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=validateDataContractCreateTransitionState)]
+pub async fn validate_data_contract_create_transition_state(
+    state_repository: ExternalStateRepositoryLike,
+    state_transition: DataContractCreateTransitionWasm,
+) -> Result<ValidationResultWasm, JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+    dpp_validate_data_contract_create_transition_state(
+        &wrapped_state_repository,
+        &state_transition.into(),
+    )
+    .await
+    .map(Into::into)
+    .map_err(from_dpp_err)
+}

package/src/document/errors/document_already_exists_error.rs

@@ -1,4 +1,4 @@
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 use dpp::prelude::DocumentTransition;
 use thiserror::Error;
 

package/src/document/errors/document_not_provided_error.rs

@@ -1,4 +1,4 @@
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 use dpp::prelude::DocumentTransition;
 use thiserror::Error;
 

package/src/document/errors/invalid_document_action_error.rs

@@ -1,4 +1,4 @@
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 use dpp::prelude::DocumentTransition;
 use thiserror::Error;
 

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_condition_error.rs

@@ -1,5 +1,5 @@
 use crate::buffer::Buffer;
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 
 use dpp::identifier::Identifier;
 use dpp::prelude::DocumentTransition;

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_execution_error.rs

@@ -1,5 +1,5 @@
 use crate::buffer::Buffer;
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 
 use dpp::identifier::Identifier;
 use dpp::prelude::DocumentTransition;

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_invalid_result_error.rs

@@ -1,5 +1,5 @@
 use crate::buffer::Buffer;
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 
 use dpp::identifier::Identifier;
 use dpp::prelude::DocumentTransition;

package/src/lib.rs

@@ -1,5 +1,3 @@
-extern crate web_sys;
-
 pub use dash_platform_protocol::*;
 pub use data_contract::*;
 pub use data_contract_factory::*;
@@ -9,6 +7,7 @@ pub use identity::*;
 pub use identity_facade::*;
 pub use identity_public_key::*;
 pub use metadata::*;
+pub use state_transition::*;
 
 mod dash_platform_protocol;
 mod data_contract;
@@ -20,6 +19,8 @@ mod identity;
 mod identity_facade;
 mod identity_public_key;
 mod metadata;
+mod state_repository;
+mod state_transition;
 
 mod utils;
 

package/src/state_repository.rs

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

package/src/state_transition/mod.rs

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

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition.spec.js

@@ -1,23 +1,24 @@
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
 
-const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
-const hash = require('@dashevo/dpp/lib/util/hash');
-const serializer = require('@dashevo/dpp/lib/util/serializer');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('DataContractCreateTransition', () => {
   let stateTransition;
   let dataContract;
-  let hashMock;
-  let encodeMock;
+  let DataContractCreateTransition;
+  let Identifier;
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
+  before(async () => {
+    ({
+      DataContractCreateTransition, Identifier,
+    } = await loadWasmDpp());
+  });
 
-    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
-    hashMock = this.sinonSandbox.stub(hash, 'hash');
+  beforeEach(() => {
+    dataContract = getDataContractFixture();
 
     stateTransition = new DataContractCreateTransition({
       protocolVersion: protocolVersion.latestVersion,
@@ -26,11 +27,6 @@ describe('DataContractCreateTransition', () => {
     });
   });
 
-  afterEach(() => {
-    encodeMock.restore();
-    hashMock.restore();
-  });
-
   describe('#getProtocolVersion', () => {
     it('should return the current protocol version', () => {
       const result = stateTransition.getProtocolVersion();
@@ -57,12 +53,10 @@ describe('DataContractCreateTransition', () => {
 
   describe('#toJSON', () => {
     it('should return State Transition as plain JS object', () => {
-      expect(stateTransition.toJSON()).to.deep.equal({
+      expect(stateTransition.toJSON(true)).to.deep.equal({
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.DATA_CONTRACT_CREATE,
         dataContract: dataContract.toJSON(),
-        signaturePublicKeyId: undefined,
-        signature: undefined,
         entropy: dataContract.getEntropy().toString('base64'),
       });
     });
@@ -70,61 +64,20 @@ describe('DataContractCreateTransition', () => {
 
   describe('#toBuffer', () => {
     it('should return serialized State Transition', () => {
-      const serializedStateTransition = Buffer.from('123');
-
-      encodeMock.returns(serializedStateTransition);
-
       const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+      protocolVersionUInt32.writeUInt32LE(stateTransition.getProtocolVersion(), 0);
 
       const result = stateTransition.toBuffer();
-
-      expect(result).to.deep.equal(
-        Buffer.concat([protocolVersionUInt32, serializedStateTransition]),
-      );
-
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
-
-      expect(encodeMock.getCall(0).args).to.have.deep.members([
-        dataToEncode,
-      ]);
-    });
-  });
-
-  describe('#hash', () => {
-    it('should return State Transition hash as hex', () => {
-      const serializedDocument = Buffer.from('123');
-      const hashedDocument = '456';
-
-      encodeMock.returns(serializedDocument);
-      hashMock.returns(hashedDocument);
-
-      const result = stateTransition.hash();
-
-      expect(result).to.equal(hashedDocument);
-
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
-
-      expect(encodeMock.getCall(0).args).to.have.deep.members([
-        dataToEncode,
-      ]);
-
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
-
-      expect(hashMock).to.have.been.calledOnceWith(
-        Buffer.concat([protocolVersionUInt32, serializedDocument]),
-      );
+      expect(result.compare(protocolVersionUInt32, 0, 4, 0, 4)).equals(0);
     });
   });
 
   describe('#getOwnerId', () => {
     it('should return owner id', async () => {
       const result = stateTransition.getOwnerId();
+      const reference = stateTransition.getDataContract().getOwnerId();
 
-      expect(result).to.equal(stateTransition.getDataContract().getOwnerId());
+      expect(result.toBuffer()).to.deep.equal(reference.toBuffer());
     });
   });
 
@@ -136,7 +89,7 @@ describe('DataContractCreateTransition', () => {
       const contractId = result[0];
 
       expect(contractId).to.be.an.instanceOf(Identifier);
-      expect(contractId).to.be.deep.equal(dataContract.getId());
+      expect(contractId.toBuffer()).to.be.deep.equal(dataContract.getId().toBuffer());
     });
   });