@dashevo/wasm-dpp 0.25.0-dev.9 → 0.25.1

package/src/state_transition/state_transition_factory.rs

@@ -1,42 +1,32 @@
-use std::{ops::Deref, sync::Arc};
-
-use dpp::{state_transition::{
-    validation::{
-        validate_state_transition_basic::StateTransitionBasicValidator,
-        validate_state_transition_by_type::StateTransitionByTypeValidator,
-    },
-    StateTransitionFactory, StateTransitionFactoryOptions, StateTransition, errors::StateTransitionError,
-}, version::ProtocolVersionValidator, data_contract::state_transition::{data_contract_create_transition::validation::state::validate_data_contract_create_transition_basic::DataContractCreateTransitionBasicValidator, data_contract_update_transition::validation::basic::DataContractUpdateTransitionBasicValidator}, identity::{state_transition::{identity_create_transition::validation::basic::IdentityCreateTransitionBasicValidator, validate_public_key_signatures::{PublicKeysSignaturesValidator}, asset_lock_proof::{AssetLockProofValidator, ChainAssetLockProofStructureValidator, InstantAssetLockProofStructureValidator, AssetLockTransactionValidator}, identity_topup_transition::validation::basic::IdentityTopUpTransitionBasicValidator, identity_credit_withdrawal_transition::validation::basic::validate_identity_credit_withdrawal_transition_basic::IdentityCreditWithdrawalTransitionBasicValidator, identity_update_transition::validate_identity_update_transition_basic::ValidateIdentityUpdateTransitionBasic}, validation::PublicKeysValidator}, document::validation::basic::validate_documents_batch_transition_basic::DocumentBatchTransitionBasicValidator, ProtocolError};
-use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
-use dpp::platform_value::Value;
-
-use crate::utils::{ToSerdeJSONExt, WithJsError};
-use crate::{
-    bls_adapter::{BlsAdapter, JsBlsAdapter},
-    errors::{from_dpp_err, from_dpp_init_error},
-    identity_facade::FromObjectOptions,
-    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
-    state_transition::errors::invalid_state_transition_error::InvalidStateTransitionErrorWasm,
-    with_js_error, DataContractCreateTransitionWasm, DataContractUpdateTransitionWasm,
-    DocumentsBatchTransitionWasm, IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm,
-    IdentityUpdateTransitionWasm,
+use crate::data_contract::{DataContractCreateTransitionWasm, DataContractUpdateTransitionWasm};
+use crate::document_batch_transition::DocumentsBatchTransitionWasm;
+use crate::errors::from_dpp_err;
+use crate::identity::state_transition::{
+    IdentityCreateTransitionWasm, IdentityCreditTransferTransitionWasm,
+    IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm,
 };
+use crate::state_transition::errors::invalid_state_transition_error::InvalidStateTransitionErrorWasm;
+use dpp::state_transition::errors::StateTransitionError;
+use dpp::state_transition::state_transition_factory::StateTransitionFactory;
+use dpp::state_transition::StateTransition;
+use dpp::ProtocolError;
+use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
 
 #[wasm_bindgen(js_name = StateTransitionFactory)]
-pub struct StateTransitionFactoryWasm(
-    StateTransitionFactory<ExternalStateRepositoryLikeWrapper, BlsAdapter>,
-);
+pub struct StateTransitionFactoryWasm(StateTransitionFactory);
 
-impl From<StateTransitionFactory<ExternalStateRepositoryLikeWrapper, BlsAdapter>>
-    for StateTransitionFactoryWasm
-{
-    fn from(
-        factory: StateTransitionFactory<ExternalStateRepositoryLikeWrapper, BlsAdapter>,
-    ) -> Self {
+impl From<StateTransitionFactory> for StateTransitionFactoryWasm {
+    fn from(factory: StateTransitionFactory) -> Self {
         Self(factory)
     }
 }
 
+impl From<&StateTransitionFactory> for StateTransitionFactoryWasm {
+    fn from(factory: &StateTransitionFactory) -> Self {
+        Self(factory.to_owned())
+    }
+}
+
 impl StateTransitionFactoryWasm {
     pub fn state_transition_wasm_from_factory_result(
         result: Result<StateTransition, ProtocolError>,
@@ -58,6 +48,9 @@ impl StateTransitionFactoryWasm {
                 StateTransition::IdentityTopUp(st) => {
                     Ok(IdentityTopUpTransitionWasm::from(st).into())
                 }
+                StateTransition::IdentityCreditTransfer(st) => {
+                    Ok(IdentityCreditTransferTransitionWasm::from(st).into())
+                }
                 StateTransition::DocumentsBatch(st) => {
                     Ok(DocumentsBatchTransitionWasm::from(st).into())
                 }
@@ -80,135 +73,131 @@ impl StateTransitionFactoryWasm {
 
 #[wasm_bindgen(js_class = StateTransitionFactory)]
 impl StateTransitionFactoryWasm {
-    #[wasm_bindgen(constructor)]
-    pub fn new(
-        state_repository: ExternalStateRepositoryLike,
-        bls_adapter: JsBlsAdapter,
-    ) -> Result<StateTransitionFactoryWasm, JsValue> {
-        let state_repository_wrapper =
-            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
-        let protocol_version_validator = Arc::new(ProtocolVersionValidator::default());
-
-        let adapter = BlsAdapter(bls_adapter);
-
-        let pk_validator =
-            Arc::new(PublicKeysValidator::new(adapter.clone()).map_err(from_dpp_init_error)?);
-        let pk_sig_validator = Arc::new(PublicKeysSignaturesValidator::new(adapter.clone()));
-
-        let asset_lock_tx_validator = Arc::new(AssetLockTransactionValidator::new(
-            state_repository_wrapper.clone(),
-        ));
-
-        let asset_lock_validator = Arc::new(AssetLockProofValidator::new(
-            InstantAssetLockProofStructureValidator::new(
-                state_repository_wrapper.clone(),
-                asset_lock_tx_validator.clone(),
-            )
-            .map_err(from_dpp_init_error)?,
-            ChainAssetLockProofStructureValidator::new(
-                state_repository_wrapper.clone(),
-                asset_lock_tx_validator,
-            )
-            .map_err(from_dpp_init_error)?,
-        ));
-
-        let state_transition_basic_validator = StateTransitionBasicValidator::new(
-            state_repository_wrapper.clone(),
-            StateTransitionByTypeValidator::new(
-                DataContractCreateTransitionBasicValidator::new(protocol_version_validator.clone())
-                    .with_js_error()?,
-                DataContractUpdateTransitionBasicValidator::new(
-                    state_repository_wrapper.clone(),
-                    protocol_version_validator.clone(),
-                )
-                .map_err(from_dpp_init_error)?,
-                IdentityCreateTransitionBasicValidator::new(
-                    protocol_version_validator.deref().clone(),
-                    pk_validator.clone(),
-                    pk_validator.clone(),
-                    asset_lock_validator.clone(),
-                    adapter,
-                    pk_sig_validator.clone(),
-                )
-                .map_err(from_dpp_init_error)?,
-                ValidateIdentityUpdateTransitionBasic::new(
-                    ProtocolVersionValidator::default(),
-                    pk_validator,
-                    pk_sig_validator,
-                )
-                .with_js_error()?,
-                IdentityTopUpTransitionBasicValidator::new(
-                    ProtocolVersionValidator::default(),
-                    asset_lock_validator,
-                )
-                .map_err(from_dpp_init_error)?,
-                IdentityCreditWithdrawalTransitionBasicValidator::new(
-                    protocol_version_validator.clone(),
-                )
-                .map_err(from_dpp_init_error)?,
-                DocumentBatchTransitionBasicValidator::new(
-                    state_repository_wrapper.clone(),
-                    protocol_version_validator.clone(),
-                ),
-            ),
-        );
-
-        let factory = StateTransitionFactory::new(
-            state_repository_wrapper,
-            Arc::new(state_transition_basic_validator),
-        );
-
-        Ok(factory.into())
-    }
-
-    #[wasm_bindgen(js_name=createFromObject)]
-    pub async fn create_from_object(
-        &self,
-        state_transition_object: JsValue,
-        options: JsValue,
-    ) -> Result<JsValue, JsValue> {
-        let options: FromObjectOptions = if options.is_object() {
-            with_js_error!(serde_wasm_bindgen::from_value(options))?
-        } else {
-            Default::default()
-        };
-
-        let raw_state_transition: Value = state_transition_object.with_serde_to_platform_value()?;
-
-        let result = self
-            .0
-            .create_from_object(
-                raw_state_transition,
-                Some(StateTransitionFactoryOptions {
-                    skip_validation: options.skip_validation.unwrap_or(false),
-                }),
-            )
-            .await;
-
-        Self::state_transition_wasm_from_factory_result(result)
-    }
+    // #[wasm_bindgen(constructor)]
+    // pub fn new(
+    //     state_repository: ExternalStateRepositoryLike,
+    //     bls_adapter: JsBlsAdapter,
+    // ) -> Result<StateTransitionFactoryWasm, JsValue> {
+    //     let state_repository_wrapper =
+    //         Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+    //     let protocol_version_validator = Arc::new(ProtocolVersionValidator::default());
+    //
+    //     let adapter = BlsAdapter(bls_adapter);
+    //
+    //     let pk_validator =
+    //         Arc::new(PublicKeysValidator::new(adapter.clone()).map_err(from_dpp_init_error)?);
+    //     let pk_sig_validator = Arc::new(PublicKeysSignaturesValidator::new(adapter.clone()));
+    //
+    //     let asset_lock_tx_validator = Arc::new(AssetLockTransactionValidator::new(
+    //         state_repository_wrapper.clone(),
+    //     ));
+    //
+    //     let asset_lock_validator = Arc::new(AssetLockProofValidator::new(
+    //         InstantAssetLockProofStructureValidator::new(
+    //             state_repository_wrapper.clone(),
+    //             asset_lock_tx_validator.clone(),
+    //         )
+    //         .map_err(from_dpp_init_error)?,
+    //         ChainAssetLockProofStructureValidator::new(
+    //             state_repository_wrapper.clone(),
+    //             asset_lock_tx_validator,
+    //         )
+    //         .map_err(from_dpp_init_error)?,
+    //     ));
+    //
+    //     let state_transition_basic_validator = StateTransitionBasicValidator::new(
+    //         state_repository_wrapper.clone(),
+    //         StateTransitionByTypeValidator::new(
+    //             DataContractCreateTransitionBasicValidator::new(protocol_version_validator.clone())
+    //                 .with_js_error()?,
+    //             DataContractUpdateTransitionBasicValidator::new(
+    //                 state_repository_wrapper.clone(),
+    //                 protocol_version_validator.clone(),
+    //             )
+    //             .map_err(from_dpp_init_error)?,
+    //             IdentityCreateTransitionBasicValidator::new(
+    //                 protocol_version_validator.deref().clone(),
+    //                 pk_validator.clone(),
+    //                 pk_validator.clone(),
+    //                 asset_lock_validator.clone(),
+    //                 adapter,
+    //                 pk_sig_validator.clone(),
+    //             )
+    //             .map_err(from_dpp_init_error)?,
+    //             ValidateIdentityUpdateTransitionBasic::new(
+    //                 ProtocolVersionValidator::default(),
+    //                 pk_validator,
+    //                 pk_sig_validator,
+    //             )
+    //             .with_js_error()?,
+    //             IdentityTopUpTransitionBasicValidator::new(
+    //                 ProtocolVersionValidator::default(),
+    //                 asset_lock_validator,
+    //             )
+    //             .map_err(from_dpp_init_error)?,
+    //             IdentityCreditWithdrawalTransitionBasicValidator::new(
+    //                 protocol_version_validator.clone(),
+    //             )
+    //             .map_err(from_dpp_init_error)?,
+    //             DocumentBatchTransitionBasicValidator::new(
+    //                 state_repository_wrapper.clone(),
+    //                 protocol_version_validator.clone(),
+    //             ),
+    //             IdentityCreditTransferTransitionBasicValidator::new(
+    //                 ProtocolVersionValidator::default(),
+    //             )
+    //             .map_err(from_dpp_init_error)?,
+    //         ),
+    //     );
+    //
+    //     let factory = StateTransitionFactory::new(
+    //         state_repository_wrapper,
+    //         Arc::new(state_transition_basic_validator),
+    //     );
+    //
+    //     Ok(factory.into())
+    // }
+    //
+    // #[wasm_bindgen(js_name=createFromObject)]
+    // pub async fn create_from_object(
+    //     &self,
+    //     state_transition_object: JsValue,
+    //     options: JsValue,
+    // ) -> Result<JsValue, JsValue> {
+    //     let options: FromObjectOptions = if options.is_object() {
+    //         with_js_error!(serde_wasm_bindgen::from_value(options))?
+    //     } else {
+    //         Default::default()
+    //     };
+    //
+    //     let raw_state_transition: Value = state_transition_object.with_serde_to_platform_value()?;
+    //
+    //     let result = self
+    //         .0
+    //         .create_from_object(
+    //             raw_state_transition,
+    //             Some(StateTransitionFactoryOptions {
+    //                 skip_validation: options.skip_validation.unwrap_or(false),
+    //             }),
+    //         )
+    //         .await;
+    //
+    //     Self::state_transition_wasm_from_factory_result(result)
+    // }
 
     #[wasm_bindgen(js_name=createFromBuffer)]
     pub async fn create_from_buffer(
         &self,
         buffer: Vec<u8>,
-        options: JsValue,
+        _options: JsValue,
     ) -> Result<JsValue, JsValue> {
-        let options: FromObjectOptions = if options.is_object() {
-            with_js_error!(serde_wasm_bindgen::from_value(options))?
-        } else {
-            Default::default()
-        };
+        // let options: FromObjectOptions = if options.is_object() {
+        //     with_js_error!(serde_wasm_bindgen::from_value(options))?
+        // } else {
+        //     Default::default()
+        // };
 
-        let result = self
-            .0
-            .create_from_buffer(
-                &buffer,
-                Some(StateTransitionFactoryOptions {
-                    skip_validation: options.skip_validation.unwrap_or(false),
-                }),
-            )
-            .await;
+        let result = self.0.create_from_buffer(&buffer);
 
         Self::state_transition_wasm_from_factory_result(result)
     }

package/src/state_transition/validation/state_transition_fee_validator.rs

@@ -1,5 +1,5 @@
 use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
-use dpp::state_transition::validation::validate_state_transition_fee::StateTransitionFeeValidator;
+use dpp::state_transition::state_transition_validation::validate_state_transition_fee::StateTransitionFeeValidator;
 use std::sync::Arc;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;

package/src/state_transition/validation/validate_state_transition_identity_signature.rs

@@ -7,10 +7,10 @@ use crate::errors::consensus::consensus_error::from_consensus_error;
 use dpp::consensus::basic::state_transition::InvalidStateTransitionTypeError;
 use dpp::consensus::basic::BasicError;
 use dpp::consensus::ConsensusError;
-use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
-use dpp::state_transition::validation::validate_state_transition_identity_signature::validate_state_transition_identity_signature;
-use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned};
+use dpp::state_transition::state_transition_validation::validate_state_transition_identity_signature::validate_state_transition_identity_signature;
+use dpp::state_transition::{StateTransition, StateTransitionIdentitySignedV0};
 
+use crate::StateTransitionExecutionContextWasm;
 use std::sync::Arc;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
@@ -23,13 +23,14 @@ struct StValidator {
 impl StValidator {
     pub async fn validate(
         &self,
-        state_transition: &mut impl StateTransitionIdentitySigned,
+        state_transition: &mut impl StateTransitionIdentitySignedV0,
+        execution_context: &StateTransitionExecutionContext,
     ) -> Result<ValidationResultWasm, JsValue> {
         let result = validate_state_transition_identity_signature(
             self.state_repository.clone(),
             state_transition,
             &self.bls,
-            &StateTransitionExecutionContext::default(), // TODO(v0.24-backport): is it fine using default context here?
+            execution_context,
         )
         .await
         .with_js_error()?;
@@ -43,12 +44,14 @@ impl StValidator {
 pub async fn validate_state_transition_identity_signature_wasm(
     external_state_repository: ExternalStateRepositoryLike,
     js_state_transition: &JsValue,
+    execution_context: &StateTransitionExecutionContextWasm,
     bls_adapter: JsBlsAdapter,
 ) -> Result<ValidationResultWasm, JsValue> {
     let bls = BlsAdapter(bls_adapter);
     let state_repository = Arc::new(ExternalStateRepositoryLikeWrapper::new(
         external_state_repository,
     ));
+    let execution_context: StateTransitionExecutionContext = execution_context.to_owned().into();
 
     let validator = StValidator {
         bls,
@@ -60,13 +63,19 @@ pub async fn validate_state_transition_identity_signature_wasm(
 
     match state_transition {
         StateTransition::DataContractCreate(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
         StateTransition::DataContractUpdate(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
         StateTransition::DocumentsBatch(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
         // TODO: We should use protocol error here, not consensus
         StateTransition::IdentityCreate(state_transition) => Err(from_consensus_error(
@@ -81,10 +90,19 @@ pub async fn validate_state_transition_identity_signature_wasm(
             )),
         )),
         StateTransition::IdentityCreditWithdrawal(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
         StateTransition::IdentityUpdate(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
+        }
+        StateTransition::IdentityCreditTransfer(mut state_transition) => {
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
     }
 }

package/src/state_transition/validation/validate_state_transition_key_signature.rs

@@ -5,7 +5,7 @@ use crate::StateTransitionExecutionContextWasm;
 use dpp::identity::state_transition::asset_lock_proof::{
     AssetLockPublicKeyHashFetcher, AssetLockTransactionOutputFetcher,
 };
-use dpp::state_transition::validation::validate_state_transition_key_signature::StateTransitionKeySignatureValidator;
+use dpp::state_transition::state_transition_validation::validate_state_transition_key_signature::StateTransitionKeySignatureValidator;
 use dpp::validation::AsyncDataValidator;
 use std::sync::Arc;
 use wasm_bindgen::prelude::wasm_bindgen;

package/src/utils.rs

@@ -1,14 +1,11 @@
 use std::collections::BTreeMap;
 use std::convert::TryInto;
 
-use anyhow::{anyhow, bail};
-use dpp::{
-    consensus::ConsensusError,
-    dashcore::{anyhow, anyhow::Context},
-    ProtocolError,
-};
+use anyhow::{anyhow, bail, Context};
+use dpp::{consensus::ConsensusError, ProtocolError};
 
 use dpp::platform_value::Value;
+use dpp::serialization::PlatformDeserializable;
 use js_sys::{Function, Uint8Array};
 use serde::de::DeserializeOwned;
 use serde_json::Value as JsonValue;
@@ -193,7 +190,7 @@ pub fn generic_of_js_val<T: RefFromWasmAbi<Abi = u32>>(
         .name();
 
     if ctor_name == class_name {
-        let ptr = js_sys::Reflect::get(js_value, &JsValue::from_str("ptr"))?;
+        let ptr = js_sys::Reflect::get(js_value, &JsValue::from_str("__wbg_ptr"))?;
         let ptr_u32: u32 = ptr
             .as_f64()
             .ok_or_else(|| JsValue::from(JsError::new("Invalid JS object pointer")))?
@@ -296,6 +293,8 @@ pub(crate) fn consensus_errors_from_buffers(
             )
             .to_vec()
         })
-        .map(|error_bytes| ConsensusError::deserialize(&error_bytes.to_vec()).with_js_error())
+        .map(|error_bytes| {
+            ConsensusError::deserialize_from_bytes(&error_bytes.to_vec()).with_js_error()
+        })
         .collect::<Result<Vec<ConsensusError>, JsValue>>()
 }

package/src/validation/validation_result.rs

@@ -3,6 +3,7 @@ use crate::{
     errors::consensus::consensus_error::from_consensus_error_ref,
     utils::{consensus_errors_from_buffers, WithJsError},
 };
+use dpp::serialization::PlatformDeserializable;
 use dpp::{consensus::ConsensusError, validation::ConsensusValidationResult};
 use js_sys::{JsString, Uint8Array};
 use wasm_bindgen::prelude::*;

package/test/integration/dataContract/DataContractFacade.spec.js

@@ -1,62 +1,55 @@
-const getDataContractJSFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const crypto = require('crypto');
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
 const getBlsAdapterMock = require('../../../lib/test/mocks/getBlsAdapterMock');
 const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
-const getPrivateAndPublicKey = require('../../../lib/test/fixtures/getPrivateAndPublicKeyForSigningFixture');
+const getPrivateAndPublicKeyForSigningFixture = require('../../../lib/test/fixtures/getPrivateAndPublicKeyForSigningFixture');
 
 const { default: loadWasmDpp } = require('../../..');
 let {
-  DashPlatformProtocol, DataContract, ValidationResult, DataContractValidator,
+  DashPlatformProtocol, DataContract, ValidationResult,
   DataContractFactory, DataContractCreateTransition, DataContractUpdateTransition,
 } = require('../../..');
 
 describe('DataContractFacade', () => {
   let dpp;
-  let dataContractJs;
+  let dataContract;
   let dataContractFactory;
-  let blsAdapter;
   let rawDataContract;
-  let dataContractWasm;
   let stateTransitionMock;
 
   before(async () => {
     ({
-      DashPlatformProtocol, DataContract, ValidationResult,
-      DataContractValidator, DataContractFactory, DataContractCreateTransition,
-      DataContractUpdateTransition,
+      DashPlatformProtocol, DataContract, ValidationResult, DataContractFactory,
+      DataContractCreateTransition, DataContractUpdateTransition,
     } = await loadWasmDpp());
   });
 
   beforeEach(async function beforeEach() {
-    blsAdapter = await getBlsAdapterMock();
     stateTransitionMock = createStateRepositoryMock(this.sinonSandbox);
     dpp = new DashPlatformProtocol(
-      blsAdapter, stateTransitionMock, { generate: () => crypto.randomBytes(32) }, 1,
+      { generate: () => crypto.randomBytes(32) }, 1,
     );
 
-    dataContractJs = await getDataContractJSFixture();
-    rawDataContract = dataContractJs.toObject();
+    dataContract = await getDataContractFixture();
+    rawDataContract = dataContract.toObject();
 
-    const dataContractValidator = new DataContractValidator();
     dataContractFactory = new DataContractFactory(
       1,
-      dataContractValidator,
+      { generate: () => crypto.randomBytes(32) },
     );
-
-    dataContractWasm = await dataContractFactory.createFromObject(rawDataContract);
   });
 
   describe('create', () => {
     it('should create DataContract', () => {
       const result = dpp.dataContract.create(
-        dataContractJs.getOwnerId(),
-        dataContractJs.getDocuments(),
+        dataContract.getOwnerId(),
+        dataContract.getDocumentSchemas(),
       );
 
       expect(result).to.be.an.instanceOf(DataContract);
 
-      expect(result.getOwnerId().toBuffer()).to.deep.equal(dataContractJs.getOwnerId().toBuffer());
-      expect(result.getDocuments()).to.deep.equal(dataContractJs.getDocuments());
+      expect(result.getOwnerId().toBuffer()).to.deep.equal(dataContract.getOwnerId().toBuffer());
+      expect(result.getDocumentSchemas()).to.deep.equal(dataContract.getDocumentSchemas());
     });
   });
 
@@ -66,15 +59,15 @@ describe('DataContractFacade', () => {
 
       expect(result).to.be.an.instanceOf(DataContract);
 
-      expect(result.toObject()).to.deep.equal(dataContractJs.toObject());
+      expect(result.toObject()).to.deep.equal(dataContract.toObject());
     });
   });
 
   describe('createFromBuffer', () => {
     it('should create DataContract from string', async () => {
       const contract = dpp.dataContract.create(
-        dataContractJs.getOwnerId(),
-        dataContractJs.getDocuments(),
+        dataContract.getOwnerId(),
+        dataContract.getDocumentSchemas(),
       );
 
       const result = await dpp.dataContract.createFromBuffer(contract.toBuffer());
@@ -87,9 +80,9 @@ describe('DataContractFacade', () => {
   describe('createDataContractCreateTransition', () => {
     it('should create DataContractCreateTransition from DataContract', async () => {
       const stateTransition = await dataContractFactory
-        .createDataContractCreateTransition(dataContractWasm);
+        .createDataContractCreateTransition(dataContract);
 
-      const result = dpp.dataContract.createDataContractCreateTransition(dataContractWasm);
+      const result = dpp.dataContract.createDataContractCreateTransition(dataContract);
 
       expect(result).to.be.an.instanceOf(DataContractCreateTransition);
 
@@ -99,12 +92,12 @@ describe('DataContractFacade', () => {
 
   describe('createDataContractUpdateTransition', () => {
     it('should create DataContractUpdateTransition from buffer', async () => {
-      const dataContractBuffer = Buffer.from('01a56324696458205a3c9565f215156cfb330ef3a4a4400a1dad7415f4f1480e072d3419bb29c12c6724736368656d61783468747470733a2f2f736368656d612e646173682e6f72672f6470702d302d342d302f6d6574612f646174612d636f6e7472616374676f776e657249645820d5199a5b19334554d5dd483af53877251584ab9a66ca777bd1b2e8d2ec4808346776657273696f6e0169646f63756d656e7473a36c6e696365446f63756d656e74a46474797065666f626a656374687265717569726564816a246372656174656441746a70726f70657274696573a1646e616d65a1647479706566737472696e67746164646974696f6e616c50726f70657274696573f46e7769746842797465417272617973a56474797065666f626a65637467696e646963657381a2646e616d6566696e646578316a70726f7065727469657381a16e6279746541727261794669656c6463617363687265717569726564816e6279746541727261794669656c646a70726f70657274696573a26e6279746541727261794669656c64a36474797065656172726179686d61784974656d731069627974654172726179f56f6964656e7469666965724669656c64a56474797065656172726179686d61784974656d731820686d696e4974656d73182069627974654172726179f570636f6e74656e744d656469615479706578216170706c69636174696f6e2f782e646173682e6470702e6964656e746966696572746164646974696f6e616c50726f70657274696573f46f696e6465786564446f63756d656e74a56474797065666f626a65637467696e646963657386a3646e616d6566696e646578316a70726f7065727469657382a168246f776e6572496463617363a16966697273744e616d656361736366756e69717565f5a3646e616d6566696e646578326a70726f7065727469657382a168246f776e6572496463617363a1686c6173744e616d656361736366756e69717565f5a2646e616d6566696e646578336a70726f7065727469657381a1686c6173744e616d6563617363a2646e616d6566696e646578346a70726f7065727469657382a16a2463726561746564417463617363a16a2475706461746564417463617363a2646e616d6566696e646578356a70726f7065727469657381a16a2475706461746564417463617363a2646e616d6566696e646578366a70726f7065727469657381a16a2463726561746564417463617363687265717569726564846966697273744e616d656a246372656174656441746a24757064617465644174686c6173744e616d656a70726f70657274696573a2686c6173744e616d65a2647479706566737472696e67696d61784c656e677468183f6966697273744e616d65a2647479706566737472696e67696d61784c656e677468183f746164646974696f6e616c50726f70657274696573f4', 'hex');
+      const dataContractBuffer = dataContract.toBuffer();
 
-      const dataContract = await dpp.dataContract.createFromBuffer(dataContractBuffer);
+      const dataContractNew = await dpp.dataContract.createFromBuffer(dataContractBuffer);
 
       const updatedDataContract = await dpp.dataContract.createFromObject(
-        dataContract.toObject(),
+        dataContractNew.toObject(),
       );
 
       updatedDataContract.incrementVersion();
@@ -112,7 +105,7 @@ describe('DataContractFacade', () => {
       const dataContractUpdateTransition = dpp.dataContract
         .createDataContractUpdateTransition(updatedDataContract);
 
-      const { identityPublicKey, privateKey } = await getPrivateAndPublicKey();
+      const { identityPublicKey, privateKey } = await getPrivateAndPublicKeyForSigningFixture();
 
       dataContractUpdateTransition.sign(
         identityPublicKey,
@@ -129,7 +122,7 @@ describe('DataContractFacade', () => {
     });
   });
 
-  describe('validate', () => {
+  describe.skip('validate', () => {
     it('should validate raw data contract', async () => {
       const result = await dpp.dataContract.validate(rawDataContract);
 
@@ -138,7 +131,7 @@ describe('DataContractFacade', () => {
     });
 
     it('should validate DataContract instance', async () => {
-      const result = await dpp.dataContract.validate(dataContractWasm);
+      const result = await dpp.dataContract.validate(dataContract);
 
       expect(result).to.be.an.instanceOf(ValidationResult);
       expect(result.getErrors().length).to.be.equal(0);