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

package/src/state_transition/validation/validate_state_transition_key_signature.rs

@@ -0,0 +1,62 @@
+use crate::errors::from_dpp_err;
+use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
+use crate::validation::ValidationResultWasm;
+use dpp::identity::state_transition::asset_lock_proof::{
+    AssetLockPublicKeyHashFetcher, AssetLockTransactionOutputFetcher,
+};
+use dpp::state_transition::validation::validate_state_transition_key_signature::StateTransitionKeySignatureValidator;
+use dpp::validation::AsyncDataValidator;
+use std::sync::Arc;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=StateTransitionKeySignatureValidator)]
+pub struct StateTransitionKeySignatureValidatorWasm(
+    StateTransitionKeySignatureValidator<ExternalStateRepositoryLikeWrapper>,
+);
+
+impl From<StateTransitionKeySignatureValidator<ExternalStateRepositoryLikeWrapper>>
+    for StateTransitionKeySignatureValidatorWasm
+{
+    fn from(
+        validator: StateTransitionKeySignatureValidator<ExternalStateRepositoryLikeWrapper>,
+    ) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class=StateTransitionKeySignatureValidator)]
+impl StateTransitionKeySignatureValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(state_repository: ExternalStateRepositoryLike) -> Self {
+        let state_repository_wrapper =
+            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+        let tx_output_fetcher =
+            AssetLockTransactionOutputFetcher::new(state_repository_wrapper.clone());
+
+        let public_key_hash_fetcher =
+            AssetLockPublicKeyHashFetcher::new(state_repository_wrapper.clone(), tx_output_fetcher);
+
+        StateTransitionKeySignatureValidator::new(state_repository_wrapper, public_key_hash_fetcher)
+            .into()
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        state_transition: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let state_transition =
+            super::super::conversion::create_state_transition_from_wasm_instance(
+                &state_transition,
+            )?;
+
+        let validation_result = self
+            .0
+            .validate(&state_transition)
+            .await
+            .map_err(from_dpp_err)?;
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/utils.rs

@@ -1,15 +1,40 @@
-use dpp::dashcore::anyhow::Context;
+use std::convert::TryInto;
+
+use anyhow::{anyhow, bail};
+use dpp::{
+    dashcore::{anyhow, anyhow::Context},
+    util::json_value::{JsonValueExt, ReplaceWith},
+    ProtocolError,
+};
+
 use js_sys::Function;
+use serde::de::DeserializeOwned;
 use serde_json::Value;
-use wasm_bindgen::prelude::*;
+use wasm_bindgen::{convert::RefFromWasmAbi, prelude::*};
+
+use crate::errors::{from_dpp_err, RustConversionError};
 
 pub trait ToSerdeJSONExt {
-    fn to_serde_json_value(&self) -> Result<Value, JsValue>;
+    fn with_serde_to_json_value(&self) -> Result<Value, JsValue>;
+    fn with_serde_into<D: DeserializeOwned>(&self) -> Result<D, JsValue>
+    where
+        D: for<'de> serde::de::Deserialize<'de> + 'static;
 }
 
 impl ToSerdeJSONExt for JsValue {
-    fn to_serde_json_value(&self) -> Result<Value, JsValue> {
-        to_serde_json_value(self)
+    /// Converts the `JsValue` into `serde_json::Value`. It's an expensive conversion,
+    /// as `JsValue` must be stringified first
+    fn with_serde_to_json_value(&self) -> Result<Value, JsValue> {
+        with_serde_to_json_value(self)
+    }
+
+    /// converts the `JsValue` into any type that is supported by serde. It's an expensive conversion
+    /// as the `jsValue` must be stringified first
+    fn with_serde_into<D>(&self) -> Result<D, JsValue>
+    where
+        D: for<'de> serde::de::Deserialize<'de> + 'static,
+    {
+        with_serde_into(self)
     }
 }
 
@@ -25,7 +50,7 @@ pub fn to_vec_of_serde_values(
 ) -> Result<Vec<Value>, JsValue> {
     values
         .into_iter()
-        .map(|v| v.as_ref().to_serde_json_value())
+        .map(|v| v.as_ref().with_serde_to_json_value())
         .collect()
 }
 
@@ -38,7 +63,7 @@ where
         .collect()
 }
 
-pub fn to_serde_json_value(data: &JsValue) -> Result<Value, JsValue> {
+pub fn with_serde_to_json_value(data: &JsValue) -> Result<Value, JsValue> {
     let data = stringify(data)?;
     let value: Value = serde_json::from_str(&data)
         .with_context(|| format!("cant convert {data:#?} to serde json value"))
@@ -46,10 +71,21 @@ pub fn to_serde_json_value(data: &JsValue) -> Result<Value, JsValue> {
     Ok(value)
 }
 
+pub fn with_serde_into<D>(data: &JsValue) -> Result<D, JsValue>
+where
+    D: for<'de> serde::de::Deserialize<'de> + 'static,
+{
+    let data = stringify(data)?;
+    let value: D = 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 ",
+        "return (value != undefined && value.type=='Buffer')  ? value.data : value ",
     );
 
     let data_string: String =
@@ -57,3 +93,169 @@ pub fn stringify(data: &JsValue) -> Result<String, JsValue> {
 
     Ok(data_string)
 }
+
+pub trait WithJsError<T> {
+    /// Converts the error into JsValue
+    fn with_js_error(self) -> Result<T, JsValue>;
+}
+
+impl<T> WithJsError<T> for Result<T, anyhow::Error> {
+    fn with_js_error(self) -> Result<T, JsValue> {
+        match self {
+            Ok(ok) => Ok(ok),
+            Err(error) => Err(format!("{error:#}").into()),
+        }
+    }
+}
+
+impl<T> WithJsError<T> for Result<T, ProtocolError> {
+    fn with_js_error(self) -> Result<T, JsValue> {
+        match self {
+            Ok(ok) => Ok(ok),
+            Err(error) => Err(from_dpp_err(error)),
+        }
+    }
+}
+
+impl<T> WithJsError<T> for Result<T, serde_json::Error> {
+    fn with_js_error(self) -> Result<T, JsValue> {
+        match self {
+            Ok(ok) => Ok(ok),
+            Err(error) => Err(RustConversionError::from(error).to_js_value()),
+        }
+    }
+}
+
+pub trait IntoWasm {
+    fn to_wasm<T: RefFromWasmAbi<Abi = u32>>(&self, class_name: &str)
+        -> Result<T::Anchor, JsValue>;
+}
+
+impl IntoWasm for JsValue {
+    fn to_wasm<T: RefFromWasmAbi<Abi = u32>>(
+        &self,
+        class_name: &str,
+    ) -> Result<T::Anchor, JsValue> {
+        generic_of_js_val::<T>(self, class_name)
+    }
+}
+
+pub fn generic_of_js_val<T: RefFromWasmAbi<Abi = u32>>(
+    js_value: &JsValue,
+    class_name: &str,
+) -> Result<T::Anchor, JsValue> {
+    if !js_value.is_object() {
+        return Err(JsError::new(
+            format!("Value supplied as {} is not an object", class_name).as_str(),
+        )
+        .into());
+    }
+
+    let ctor_name = js_sys::Object::get_prototype_of(js_value)
+        .constructor()
+        .name();
+
+    if ctor_name == class_name {
+        let ptr = js_sys::Reflect::get(js_value, &JsValue::from_str("ptr"))?;
+        let ptr_u32: u32 = ptr
+            .as_f64()
+            .ok_or_else(|| JsValue::from(JsError::new("Invalid JS object pointer")))?
+            as u32;
+        let reference = unsafe { T::ref_from_abi(ptr_u32) };
+        Ok(reference)
+    } else {
+        let error_string = format!(
+            "JS object constructor name mismatch. Expected {}, provided {}.",
+            class_name, ctor_name
+        );
+        Err(JsError::new(&error_string).into())
+    }
+}
+
+pub const SKIP_VALIDATION_PROPERTY_NAME: &str = "skipValidation";
+
+pub fn get_bool_from_options(
+    options: JsValue,
+    property: &str,
+    default: bool,
+) -> Result<bool, JsValue> {
+    if options.is_object() {
+        let val2 = options.with_serde_to_json_value()?;
+        let kek = val2
+            .as_object()
+            .ok_or_else(|| JsError::new("Can't parse options"))?;
+        let kek2 = kek
+            .get(property)
+            .ok_or_else(|| JsError::new(&format!("Can't get property {} of options", property)))?;
+        Ok(kek2
+            .as_bool()
+            .ok_or_else(|| JsError::new(&format!("Option {} is not a boolean", property)))?)
+    } else {
+        Ok(default)
+    }
+}
+
+pub fn get_class_name(value: &JsValue) -> String {
+    js_sys::Object::get_prototype_of(value)
+        .constructor()
+        .name()
+        .into()
+}
+
+pub fn try_to_u64(value: JsValue) -> Result<u64, anyhow::Error> {
+    let result = if value.is_bigint() {
+        js_sys::BigInt::new(&value)
+            .map_err(|e| anyhow!("unable to create bigInt: {}", e.to_string()))?
+            .try_into()
+            .map_err(|e| anyhow!("conversion of BigInt to u64 failed: {:#}", e))
+    } else if value.as_f64().is_some() {
+        let number = js_sys::Number::from(value);
+        convert_number_to_u64(number)
+    } else {
+        bail!("supported types are Number or BigInt")
+    };
+
+    result
+}
+
+pub fn convert_number_to_u64(js_number: js_sys::Number) -> Result<u64, anyhow::Error> {
+    if let Some(float_number) = js_number.as_f64() {
+        if float_number.is_nan() || float_number.is_infinite() {
+            bail!("received an invalid timestamp: the number is either NaN or Inf")
+        }
+        if float_number < 0. {
+            bail!("received an invalid timestamp: the number is negative");
+        }
+        if float_number.fract() != 0. {
+            bail!("received an invalid timestamp: the number is fractional")
+        }
+        if float_number > u64::MAX as f64 {
+            bail!("received an invalid timestamp: the number is > u64::max")
+        }
+
+        return Ok(float_number as u64);
+    }
+    bail!("the value is not a number")
+}
+
+pub(crate) fn replace_identifiers_with_bytes_without_failing<'a>(
+    value: &mut Value,
+    paths: impl IntoIterator<Item = &'a str>,
+) {
+    // Errors are ignored. When `Buffer` crosses the WASM boundary it becomes an Array.
+    // When `Identifier` crosses the WASM boundary it becomes a String. From perspective of JS
+    // `Identifier` and `Buffer` are used interchangeably, so we we can expect the replacing may fail when `Buffer` is provided
+    let _ = value
+        .replace_identifier_paths(paths, ReplaceWith::Bytes)
+        .with_js_error();
+}
+
+// The trait `Inner` provides better flexibility and visibility when you need to switch
+// between WASM structure and original structure.
+pub(crate) trait Inner {
+    type InnerItem;
+
+    fn into_inner(self) -> Self::InnerItem;
+    fn inner(&self) -> &Self::InnerItem;
+    fn inner_mut(&mut self) -> &mut Self::InnerItem;
+}

package/src/validation/json_schema_validator.rs

@@ -0,0 +1,41 @@
+use anyhow::Context;
+use dpp::validation::JsonSchemaValidator;
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+use crate::utils::{ToSerdeJSONExt, WithJsError};
+
+#[wasm_bindgen(js_name=JsonSchemaValidator)]
+pub struct JsonSchemaValidatorWasm(JsonSchemaValidator);
+
+#[wasm_bindgen(js_class=JsonSchemaValidator)]
+impl JsonSchemaValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        schema_js: &JsValue,
+        definitions: &JsValue,
+    ) -> Result<JsonSchemaValidatorWasm, JsValue> {
+        let schema = schema_js.with_serde_to_json_value()?;
+        let maybe_defs: Option<Value> = if definitions.is_object() {
+            Some(definitions.with_serde_to_json_value()?)
+        } else {
+            None
+        };
+
+        let validator = if let Some(defs) = maybe_defs {
+            let map = defs
+                .as_object()
+                .context("definitions are not a map")
+                .with_js_error()?;
+            JsonSchemaValidator::new_with_definitions(schema, map)
+                .context("Schema Validator creation with definitions failed")
+                .with_js_error()?
+        } else {
+            JsonSchemaValidator::new(schema)
+                .context("Schema Validator creation failed")
+                .with_js_error()?
+        };
+
+        Ok(JsonSchemaValidatorWasm(validator))
+    }
+}

package/src/validation/mod.rs

@@ -1,3 +1,5 @@
+mod json_schema_validator;
 mod validation_result;
 
+pub use json_schema_validator::*;
 pub use validation_result::*;

package/src/validation/validation_result.rs

@@ -1,10 +1,20 @@
 use crate::errors::consensus_error::from_consensus_error_ref;
-use dpp::validation::ValidationResult;
+use dpp::{consensus::ConsensusError, validation::ValidationResult};
 use js_sys::JsString;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=ValidationResult)]
-pub struct ValidationResultWasm(ValidationResult<()>);
+#[derive(Debug)]
+pub struct ValidationResultWasm(ValidationResult<JsValue>);
+
+impl<T> From<ValidationResult<T>> for ValidationResultWasm
+where
+    T: Into<JsValue> + Clone,
+{
+    fn from(validation_result: ValidationResult<T>) -> Self {
+        ValidationResultWasm(validation_result.map(Into::into))
+    }
+}
 
 #[wasm_bindgen(js_class=ValidationResult)]
 impl ValidationResultWasm {
@@ -32,10 +42,24 @@ impl ValidationResultWasm {
             .map(from_consensus_error_ref)
             .collect()
     }
+
+    #[wasm_bindgen(js_name=getData)]
+    pub fn get_data(&self) -> JsValue {
+        self.0.data().unwrap_or(&JsValue::undefined()).to_owned()
+    }
+
+    #[wasm_bindgen(js_name=getFirstError)]
+    pub fn get_first_error(&self) -> JsValue {
+        if !self.0.errors.is_empty() {
+            from_consensus_error_ref(&self.0.errors[0])
+        } else {
+            JsValue::undefined()
+        }
+    }
 }
 
-impl From<ValidationResult<()>> for ValidationResultWasm {
-    fn from(validation_result: ValidationResult<()>) -> Self {
-        ValidationResultWasm(validation_result)
+impl ValidationResultWasm {
+    pub fn add_error(&mut self, error: impl Into<ConsensusError>) {
+        self.0.add_error(error)
     }
 }

package/src/version/mod.rs

@@ -0,0 +1,2 @@
+mod protocol_version;
+pub use protocol_version::*;

package/src/version/protocol_version.rs

@@ -0,0 +1,103 @@
+use crate::errors::CompatibleProtocolVersionIsNotDefinedErrorWasm;
+use crate::utils::ToSerdeJSONExt;
+use crate::validation::ValidationResultWasm;
+use dpp::util::json_value::JsonValueExt;
+use dpp::version::ProtocolVersionValidator;
+use std::collections::HashMap;
+use std::convert::TryFrom;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ProtocolVersionValidator)]
+pub struct ProtocolVersionValidatorWasm(ProtocolVersionValidator);
+
+#[wasm_bindgen(js_class=ProtocolVersionValidator)]
+impl ProtocolVersionValidatorWasm {
+    // TODO should the constructor be without parameters?
+    #[wasm_bindgen(constructor)]
+    pub fn new(options: JsValue) -> Result<ProtocolVersionValidatorWasm, JsValue> {
+        if options.is_undefined() {
+            Ok(ProtocolVersionValidatorWasm(
+                ProtocolVersionValidator::default(),
+            ))
+        } else {
+            let metadata_options = options.with_serde_to_json_value()?;
+            let current_protocol_version: u32 = metadata_options
+                .get_u32("currentProtocolVersion")
+                .map_err(|e| JsError::new(&e.to_string()))?;
+            let latest_protocol_version: u32 = metadata_options
+                .get_u32("latestProtocolVersion")
+                .map_err(|e| JsError::new(&e.to_string()))?;
+            let compatibility_map_value: serde_json::Value = metadata_options
+                .get_value("versionCompatibilityMap")
+                .map(|v| v.clone())
+                .map_err(|e| JsError::new(&e.to_string()))?;
+
+            let hash_map = compatibility_map_value
+                .as_object()
+                .ok_or_else(|| {
+                    JsValue::from(JsError::new("Expected compatibility map to be an object"))
+                })?
+                .into_iter()
+                .map(|(key, value)| {
+                    let new_key = key
+                        .parse::<u32>()
+                        .map_err(|e| JsError::new(&*e.to_string()))?;
+
+                    let new_value_64 = value.as_u64().ok_or_else(|| {
+                        JsError::new("Expect values in compatibility map to contain only numbers")
+                    })?;
+                    let new_value =
+                        u32::try_from(new_value_64).map_err(|e| JsError::new(&*e.to_string()))?;
+
+                    Ok((new_key, new_value))
+                })
+                .collect::<Result<HashMap<u32, u32>, JsError>>()?;
+
+            Ok(ProtocolVersionValidatorWasm(ProtocolVersionValidator::new(
+                current_protocol_version,
+                latest_protocol_version,
+                hash_map,
+            )))
+        }
+    }
+
+    #[wasm_bindgen]
+    pub fn validate(&self, version: u32) -> Result<ValidationResultWasm, JsValue> {
+        self.0
+            .validate(version)
+            .map(|v| v.map(|_| JsValue::undefined()))
+            .map(ValidationResultWasm::from)
+            .map_err(|e| CompatibleProtocolVersionIsNotDefinedErrorWasm::new(e).into())
+            .into()
+    }
+}
+
+impl ProtocolVersionValidatorWasm {
+    pub fn protocol_version(&self) -> u32 {
+        self.0.protocol_version()
+    }
+}
+
+impl From<ProtocolVersionValidator> for ProtocolVersionValidatorWasm {
+    fn from(doc_validator: ProtocolVersionValidator) -> Self {
+        ProtocolVersionValidatorWasm(doc_validator)
+    }
+}
+
+impl From<&ProtocolVersionValidator> for ProtocolVersionValidatorWasm {
+    fn from(doc_validator: &ProtocolVersionValidator) -> Self {
+        ProtocolVersionValidatorWasm(doc_validator.clone())
+    }
+}
+
+impl From<ProtocolVersionValidatorWasm> for ProtocolVersionValidator {
+    fn from(val: ProtocolVersionValidatorWasm) -> Self {
+        val.0
+    }
+}
+
+impl From<&ProtocolVersionValidatorWasm> for ProtocolVersionValidator {
+    fn from(val: &ProtocolVersionValidatorWasm) -> Self {
+        val.0.clone()
+    }
+}

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

@@ -1,72 +1,87 @@
-const DashPlatformProtocol = require('@dashevo/dpp/lib/DashPlatformProtocol');
+const getDataContractJSFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
+const getBlsAdapterMock = require('../../../lib/test/mocks/getBlsAdapterMock');
 
-const DataContract = require('@dashevo/dpp/lib/dataContract/DataContract');
-
-const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
-
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-
-const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
-
-const DataContractFactory = require('@dashevo/dpp/lib/dataContract/DataContractFactory');
+const { default: loadWasmDpp } = require('../../..');
+let {
+  DashPlatformProtocol, DataContract, ValidationResult, DataContractValidator,
+  DataContractFactory, DataContractCreateTransition,
+} = require('../../..');
 
 describe('DataContractFacade', () => {
   let dpp;
-  let dataContract;
+  let dataContractJs;
   let dataContractFactory;
+  let blsAdapter;
+  let rawDataContract;
+  let dataContractWasm;
+
+  before(async () => {
+    ({
+      DashPlatformProtocol, DataContract, ValidationResult,
+      DataContractValidator, DataContractFactory, DataContractCreateTransition,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(async () => {
-    dpp = new DashPlatformProtocol();
-    await dpp.initialize();
+    blsAdapter = await getBlsAdapterMock();
+    dpp = new DashPlatformProtocol(blsAdapter);
 
-    dataContract = getDataContractFixture();
+    dataContractJs = await getDataContractJSFixture();
+    rawDataContract = dataContractJs.toObject();
 
+    const dataContractValidator = new DataContractValidator();
     dataContractFactory = new DataContractFactory(
-      dpp,
-      undefined,
-      undefined,
+      1,
+      dataContractValidator,
     );
+
+    dataContractWasm = await dataContractFactory.createFromObject(rawDataContract);
   });
 
   describe('create', () => {
     it('should create DataContract', () => {
       const result = dpp.dataContract.create(
-        dataContract.getOwnerId(),
-        dataContract.getDocuments(),
+        dataContractJs.getOwnerId(),
+        dataContractJs.getDocuments(),
       );
 
       expect(result).to.be.an.instanceOf(DataContract);
 
-      expect(result.getOwnerId()).to.deep.equal(dataContract.getOwnerId());
-      expect(result.getDocuments()).to.equal(dataContract.getDocuments());
+      expect(result.getOwnerId().toBuffer()).to.deep.equal(dataContractJs.getOwnerId().toBuffer());
+      expect(result.getDocuments()).to.deep.equal(dataContractJs.getDocuments());
     });
   });
 
   describe('createFromObject', () => {
     it('should create DataContract from plain object', async () => {
-      const result = await dpp.dataContract.createFromObject(dataContract.toObject());
+      const result = await dpp.dataContract.createFromObject(rawDataContract);
 
       expect(result).to.be.an.instanceOf(DataContract);
 
-      expect(result.toObject()).to.deep.equal(dataContract.toObject());
+      expect(result.toObject()).to.deep.equal(dataContractJs.toObject());
     });
   });
 
   describe('createFromBuffer', () => {
     it('should create DataContract from string', async () => {
-      const result = await dpp.dataContract.createFromBuffer(dataContract.toBuffer());
+      const contract = dpp.dataContract.create(
+        dataContractJs.getOwnerId(),
+        dataContractJs.getDocuments(),
+      );
 
-      expect(result).to.be.an.instanceOf(DataContract);
+      const result = await dpp.dataContract.createFromBuffer(contract.toBuffer());
 
-      expect(result.toObject()).to.deep.equal(dataContract.toObject());
+      expect(result).to.be.an.instanceOf(DataContract);
+      expect(result.toObject()).to.deep.equal(contract.toObject());
     });
   });
 
   describe('createDataContractCreateTransition', () => {
-    it('should create DataContractCreateTransition from DataContract', () => {
-      const stateTransition = dataContractFactory.createDataContractCreateTransition(dataContract);
+    it('should create DataContractCreateTransition from DataContract', async () => {
+      const stateTransition = await dataContractFactory
+        .createDataContractCreateTransition(dataContractWasm);
 
-      const result = dpp.dataContract.createDataContractCreateTransition(dataContract);
+      const result = dpp.dataContract.createDataContractCreateTransition(dataContractWasm);
 
       expect(result).to.be.an.instanceOf(DataContractCreateTransition);
 
@@ -76,9 +91,10 @@ describe('DataContractFacade', () => {
 
   describe('validate', () => {
     it('should validate DataContract', async () => {
-      const result = await dpp.dataContract.validate(dataContract);
+      const result = await dpp.dataContract.validate(rawDataContract);
 
       expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.getErrors().length).to.be.equal(0);
     });
   });
 });