@dashevo/wasm-dpp 0.23.0-dev.15 → 0.24.0-dev.11

package/src/identity_public_key/purpose.rs

@@ -0,0 +1,24 @@
+use dpp::identity::Purpose;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = KeyPurpose)]
+pub enum PurposeWasm {
+    /// at least one authentication key must be registered for all security levels
+    AUTHENTICATION = 0,
+    /// this key cannot be used for signing documents
+    ENCRYPTION = 1,
+    /// this key cannot be used for signing documents
+    DECRYPTION = 2,
+    WITHDRAW = 3,
+}
+
+impl From<Purpose> for PurposeWasm {
+    fn from(p: Purpose) -> Self {
+        match p {
+            Purpose::AUTHENTICATION => PurposeWasm::AUTHENTICATION,
+            Purpose::ENCRYPTION => PurposeWasm::ENCRYPTION,
+            Purpose::DECRYPTION => PurposeWasm::DECRYPTION,
+            Purpose::WITHDRAW => PurposeWasm::WITHDRAW,
+        }
+    }
+}

package/src/identity_public_key/security_level.rs

@@ -0,0 +1,21 @@
+use dpp::identity::SecurityLevel;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = "KeySecurityLevel")]
+pub enum SecurityLevelWasm {
+    MASTER = 0,
+    CRITICAL = 1,
+    HIGH = 2,
+    MEDIUM = 3,
+}
+
+impl From<SecurityLevel> for SecurityLevelWasm {
+    fn from(level: SecurityLevel) -> Self {
+        match level {
+            SecurityLevel::CRITICAL => Self::CRITICAL,
+            SecurityLevel::HIGH => Self::HIGH,
+            SecurityLevel::MASTER => Self::MASTER,
+            SecurityLevel::MEDIUM => Self::MEDIUM,
+        }
+    }
+}

package/src/lib.rs

@@ -0,0 +1,29 @@
+pub use dash_platform_protocol::*;
+pub use data_contract::*;
+pub use data_contract_factory::*;
+pub use document::*;
+pub use identity::*;
+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;
+mod data_contract_factory;
+mod document;
+pub mod errors;
+mod identifier;
+mod identity;
+mod identity_facade;
+mod identity_public_key;
+mod metadata;
+mod state_repository;
+mod state_transition;
+
+mod utils;
+
+mod bls_adapter;
+mod buffer;
+pub mod validation_result;

package/src/metadata.rs

@@ -0,0 +1,54 @@
+#![allow(clippy::from_over_into)]
+
+pub use serde::{Deserialize, Serialize};
+use wasm_bindgen::prelude::*;
+
+use dpp::metadata::Metadata;
+
+#[wasm_bindgen(js_name=Metadata)]
+#[derive(Debug)]
+pub struct MetadataWasm(Metadata);
+
+impl std::convert::From<Metadata> for MetadataWasm {
+    fn from(v: Metadata) -> Self {
+        MetadataWasm(v)
+    }
+}
+impl std::convert::Into<Metadata> for MetadataWasm {
+    fn into(self) -> Metadata {
+        self.0
+    }
+}
+
+//? probably it should be a separate trait with blanket implementation
+#[wasm_bindgen(js_class=Metadata)]
+impl MetadataWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(block_height: JsValue, core_chain_locked_height: JsValue) -> Self {
+        // TODO: return an error instead of unwraps
+        let block_height = block_height.as_f64().unwrap() as u64;
+        let core_chain_locked_height = core_chain_locked_height.as_f64().unwrap() as u64;
+        let inner = Metadata {
+            block_height,
+            core_chain_locked_height,
+        };
+        inner.into()
+    }
+
+    #[wasm_bindgen(js_name=from)]
+    pub fn from(object: JsValue) -> Self {
+        let i: Metadata = serde_json::from_str(&object.as_string().unwrap()).unwrap();
+        MetadataWasm(i)
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> JsValue {
+        serde_wasm_bindgen::to_value(&self.0).unwrap()
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> JsValue {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        self.0.serialize(&serializer).expect("implements Serialize")
+    }
+}

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/src/utils.rs

@@ -0,0 +1,59 @@
+use dpp::dashcore::anyhow::Context;
+use js_sys::Function;
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+pub trait ToSerdeJSONExt {
+    fn to_serde_json_value(&self) -> Result<Value, JsValue>;
+}
+
+impl ToSerdeJSONExt for JsValue {
+    fn to_serde_json_value(&self) -> Result<Value, JsValue> {
+        to_serde_json_value(self)
+    }
+}
+
+pub fn to_vec_js<T>(iter: impl IntoIterator<Item = T>) -> Vec<JsValue>
+where
+    T: Into<JsValue>,
+{
+    iter.into_iter().map(|v| v.into()).collect()
+}
+
+pub fn to_vec_of_serde_values(
+    values: impl IntoIterator<Item = impl AsRef<JsValue>>,
+) -> Result<Vec<Value>, JsValue> {
+    values
+        .into_iter()
+        .map(|v| v.as_ref().to_serde_json_value())
+        .collect()
+}
+
+pub fn into_vec_of<T>(iter: &[JsValue]) -> Vec<T>
+where
+    T: for<'de> serde::de::Deserialize<'de>,
+{
+    iter.iter()
+        .map(|v| serde_wasm_bindgen::from_value(v.clone()).expect("data malformed"))
+        .collect()
+}
+
+pub fn to_serde_json_value(data: &JsValue) -> Result<Value, JsValue> {
+    let data = stringify(data)?;
+    let value: Value = serde_json::from_str(&data)
+        .with_context(|| format!("cant convert {:#?} to serde json value", data))
+        .map_err(|e| format!("{:#}", e))?;
+    Ok(value)
+}
+
+pub fn stringify(data: &JsValue) -> Result<String, JsValue> {
+    let replacer_func = Function::new_with_args(
+        "key, value",
+        "return value.type=='Buffer' ? value.data : value ",
+    );
+
+    let data_string: String =
+        js_sys::JSON::stringify_with_replacer(data, &JsValue::from(replacer_func))?.into();
+
+    Ok(data_string)
+}

package/src/validation_result.rs

@@ -0,0 +1,41 @@
+use crate::errors::consensus_error::from_consensus_error_ref;
+use dpp::validation::ValidationResult;
+use js_sys::JsString;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ValidationResult)]
+pub struct ValidationResultWasm(ValidationResult<()>);
+
+#[wasm_bindgen(js_class=ValidationResult)]
+impl ValidationResultWasm {
+    /// This is just a test method - doesn't need to be in the resulted binding. Please
+    /// remove before shipping
+    #[wasm_bindgen(js_name=errorsText)]
+    pub fn errors_text(&self) -> Vec<JsString> {
+        self.0
+            .errors()
+            .iter()
+            .map(|e| e.to_string().into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=isValid)]
+    pub fn is_valid(&self) -> bool {
+        self.0.is_valid()
+    }
+
+    #[wasm_bindgen(js_name=getErrors)]
+    pub fn errors(&self) -> Vec<JsValue> {
+        self.0
+            .errors()
+            .iter()
+            .map(from_consensus_error_ref)
+            .collect()
+    }
+}
+
+impl From<ValidationResult<()>> for ValidationResultWasm {
+    fn from(validation_result: ValidationResult<()>) -> Self {
+        ValidationResultWasm(validation_result)
+    }
+}

package/test/integration/DashPlatformProtocol.spec.js

@@ -1,7 +1,7 @@
-const DashPlatformProtocol = require('../../lib/DashPlatformProtocol');
-const protocolVersion = require('../../lib/version/protocolVersion');
-const getChainAssetLockProofFixture = require('../../lib/test/fixtures/getChainAssetLockProofFixture');
-const generateRandomIdentifier = require('../../lib/test/utils/generateRandomIdentifier');
+const DashPlatformProtocol = require('@dashevo/dpp/lib/DashPlatformProtocol');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
+const getChainAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
+const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
 
 describe('DashPlatformProtocol', () => {
   let dpp;

package/test/integration/ajv/keywords/byteArray/addByteArrayKeyword.spec.js

@@ -1,7 +1,7 @@
 const { default: Ajv } = require('ajv');
 
-const addByteArrayKeyword = require('../../../../../lib/ajv/keywords/byteArray/addByteArrayKeyword');
-const byteArray = require('../../../../../lib/ajv/keywords/byteArray/byteArray');
+const addByteArrayKeyword = require('@dashevo/dpp/lib/ajv/keywords/byteArray/addByteArrayKeyword');
+const byteArray = require('@dashevo/dpp/lib/ajv/keywords/byteArray/byteArray');
 
 describe('addByteArrayKeyword', () => {
   let ajv;

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

@@ -1,14 +1,14 @@
-const DashPlatformProtocol = require('../../../lib/DashPlatformProtocol');
+const DashPlatformProtocol = require('@dashevo/dpp/lib/DashPlatformProtocol');
 
-const DataContract = require('../../../lib/dataContract/DataContract');
+const DataContract = require('@dashevo/dpp/lib/dataContract/DataContract');
 
-const DataContractCreateTransition = require('../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
 
-const ValidationResult = require('../../../lib/validation/ValidationResult');
+const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
 
-const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
-const DataContractFactory = require('../../../lib/dataContract/DataContractFactory');
+const DataContractFactory = require('@dashevo/dpp/lib/dataContract/DataContractFactory');
 
 describe('DataContractFacade', () => {
   let dpp;

package/test/integration/dataContract/stateTransition/DataContractCreateTransition/validation/basic/validateDataContractCreateTransitionBasicFactory.spec.js

@@ -2,27 +2,27 @@ const crypto = require('crypto');
 
 const { getRE2Class } = require('@dashevo/wasm-re2');
 
-const createAjv = require('../../../../../../../lib/ajv/createAjv');
+const createAjv = require('@dashevo/dpp/lib/ajv/createAjv');
 
-const JsonSchemaValidator = require('../../../../../../../lib/validation/JsonSchemaValidator');
+const JsonSchemaValidator = require('@dashevo/dpp/lib/validation/JsonSchemaValidator');
 
-const protocolVersion = require('../../../../../../../lib/version/protocolVersion');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const validateDataContractCreateTransitionBasicFactory = require('../../../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/validation/basic/validateDataContractCreateTransitionBasicFactory');
+const validateDataContractCreateTransitionBasicFactory = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/validation/basic/validateDataContractCreateTransitionBasicFactory');
 
-const DataContractCreateTransition = require('../../../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
 
-const getDataContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
 const {
   expectValidationError,
   expectJsonSchemaError,
-} = require('../../../../../../../lib/test/expect/expectError');
+} = require('@dashevo/dpp/lib/test/expect/expectError');
 
-const ValidationResult = require('../../../../../../../lib/validation/ValidationResult');
+const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
 
-const InvalidDataContractIdError = require('../../../../../../../lib/errors/consensus/basic/dataContract/InvalidDataContractIdError');
-const SomeConsensusError = require('../../../../../../../lib/test/mocks/SomeConsensusError');
+const InvalidDataContractIdError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/InvalidDataContractIdError');
+const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
 
 describe('validateDataContractCreateTransitionBasicFactory', () => {
   let validateDataContractMock;

package/test/integration/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateDataContractUpdateTransitionBasicFactory.spec.js

@@ -1,35 +1,35 @@
-const lodashClone = require('lodash.clonedeep');
+const lodashClone = require('lodash/cloneDeep');
 
 const jsonPatch = require('fast-json-patch');
 const jsonSchemaDiffValidator = require('json-schema-diff-validator');
 
 const { getRE2Class } = require('@dashevo/wasm-re2');
 
-const createAjv = require('../../../../../../../lib/ajv/createAjv');
+const createAjv = require('@dashevo/dpp/lib/ajv/createAjv');
 
-const JsonSchemaValidator = require('../../../../../../../lib/validation/JsonSchemaValidator');
+const JsonSchemaValidator = require('@dashevo/dpp/lib/validation/JsonSchemaValidator');
 
-const protocolVersion = require('../../../../../../../lib/version/protocolVersion');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
-const validateDataContractUpdateTransitionBasicFactory = require('../../../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateDataContractUpdateTransitionBasicFactory');
+const validateDataContractUpdateTransitionBasicFactory = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateDataContractUpdateTransitionBasicFactory');
 
-const DataContractUpdateTransition = require('../../../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
+const DataContractUpdateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
 
-const getDataContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
 const {
   expectValidationError,
   expectJsonSchemaError,
-} = require('../../../../../../../lib/test/expect/expectError');
+} = require('@dashevo/dpp/lib/test/expect/expectError');
 
-const ValidationResult = require('../../../../../../../lib/validation/ValidationResult');
+const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
 
-const SomeConsensusError = require('../../../../../../../lib/test/mocks/SomeConsensusError');
-const DataContractImmutablePropertiesUpdateError = require('../../../../../../../lib/errors/consensus/basic/dataContract/DataContractImmutablePropertiesUpdateError');
-const IncompatibleDataContractSchemaError = require('../../../../../../../lib/errors/consensus/basic/dataContract/IncompatibleDataContractSchemaError');
-const StateTransitionExecutionContext = require('../../../../../../../lib/stateTransition/StateTransitionExecutionContext');
+const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
+const DataContractImmutablePropertiesUpdateError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractImmutablePropertiesUpdateError');
+const IncompatibleDataContractSchemaError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/IncompatibleDataContractSchemaError');
+const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
 
 describe('validateDataContractUpdateTransitionBasicFactory', () => {
   let validateDataContractMock;