feat(dpp): AbstractConsensusError tests and extensions

packages/wasm-dpp/lib/test/expect/expectError.js

@@ -12,12 +12,14 @@ const expectError = {
     const wasmDpp = await loadWasmDpp();
     if (!errorClass) {
       // eslint-disable-next-line no-param-reassign
-      errorClass = wasmDpp.ValidationResult;
+      errorClass = TypeError;
     }
     expect(result).to.be.an.instanceOf(wasmDpp.ValidationResult);
     expect(result.getErrors()).to.have.lengthOf(count);
 
-    result.getErrors().forEach((error) => expect(error).to.be.an.instanceOf(errorClass));
+    result.getErrors().forEach((error) => {
+      expect(error).to.be.an.instanceOf(errorClass);
+    });
   },
 
   /**

packages/wasm-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_error.rs

@@ -16,12 +16,12 @@ impl From<&DuplicatedIdentityPublicKeyError> for DuplicatedIdentityPublicKeyErro
 #[wasm_bindgen(js_class=DuplicatedIdentityPublicKeyError)]
 impl DuplicatedIdentityPublicKeyErrorWasm {
     #[wasm_bindgen(js_name=getDuplicatedPublicKeysIds)]
-    pub fn duplicated_public_keys_ids(&self) -> Vec<u32> {
+    pub fn duplicated_public_keys_ids(&self) -> js_sys::Array {
         // TODO: key ids probably should be u32
         self.inner
             .duplicated_public_keys_ids()
             .iter()
-            .map(|id| *id as u32)
+            .map(|id| JsValue::from(*id as u32))
             .collect()
     }
 

packages/wasm-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_id_error.rs

@@ -16,12 +16,12 @@ impl From<&DuplicatedIdentityPublicKeyIdError> for DuplicatedIdentityPublicKeyId
 #[wasm_bindgen(js_class=DuplicatedIdentityPublicKeyIdError)]
 impl DuplicatedIdentityPublicKeyIdErrorWasm {
     #[wasm_bindgen(js_name=getDuplicatedIds)]
-    pub fn duplicated_ids(&self) -> Vec<u32> {
+    pub fn duplicated_ids(&self) -> js_sys::Array {
         // TODO: key ids probably should be u32
         self.inner
             .duplicated_ids()
             .iter()
-            .map(|id| *id as u32)
+            .map(|id| JsValue::from(*id as u32))
             .collect()
     }
 

packages/wasm-dpp/src/errors/consensus/basic/identity/invalid_identity_public_key_security_level_error.rs

@@ -25,12 +25,12 @@ impl InvalidIdentityPublicKeySecurityLevelErrorWasm {
         self.inner.public_key_id() as u32
     }
 
-    #[wasm_bindgen(js_name=getPurpose)]
+    #[wasm_bindgen(js_name=getPublicKeyPurpose)]
     pub fn purpose(&self) -> u8 {
         self.inner.purpose() as u8
     }
 
-    #[wasm_bindgen(js_name=getSecurityLevel)]
+    #[wasm_bindgen(js_name=getPublicKeySecurityLevel)]
     pub fn security_level(&self) -> u8 {
         self.inner.security_level() as u8
     }

packages/wasm-dpp/src/errors/consensus/basic/json_schema_error.rs

@@ -141,7 +141,7 @@ impl From<&ValidationErrorKind> for Params {
                 .build(),
             ValidationErrorKind::MinItems { limit } => ParamsBuilder::new()
                 .set_keyword("minItems")
-                .add_param("maximum", Value::from(*limit))
+                .add_param("minItems", Value::from(*limit))
                 .build(),
             ValidationErrorKind::Minimum { limit } => ParamsBuilder::new()
                 .set_keyword("minimum")

packages/wasm-dpp/src/identity_facade.rs → packages/wasm-dpp/src/identity/identity_facade.rs

@@ -6,7 +6,7 @@ use dpp::identity::validation::PublicKeysValidator;
 use dpp::identity::IdentityFacade;
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
-use crate::validation_result::ValidationResultWasm;
+use crate::validation::ValidationResultWasm;
 use dpp::version::ProtocolVersionValidator;
 use dpp::NonConsensusError;
 

packages/wasm-dpp/src/identity_public_key/mod.rs → packages/wasm-dpp/src/identity/identity_public_key/mod.rs

@@ -14,9 +14,6 @@ mod security_level;
 pub use security_level::*;
 
 mod key_type;
-mod public_keys_validator;
-
-pub use public_keys_validator::*;
 
 pub use key_type::*;
 

packages/wasm-dpp/src/identity.rs → packages/wasm-dpp/src/identity/mod.rs

@@ -1,3 +1,7 @@
+pub mod identity_facade;
+mod identity_public_key;
+mod validation;
+
 use js_sys::Array;
 use serde_json::Value;
 use wasm_bindgen::prelude::*;
@@ -12,8 +16,8 @@ use crate::errors::from_dpp_err;
 use crate::identifier::IdentifierWrapper;
 use crate::utils;
 use crate::utils::to_vec_of_serde_values;
-use crate::IdentityPublicKeyWasm;
 use crate::MetadataWasm;
+pub use identity_public_key::*;
 
 #[wasm_bindgen(js_name=Identity)]
 #[derive(Clone)]

packages/wasm-dpp/src/identity/validation/mod.rs

@@ -0,0 +1,3 @@
+mod public_keys_validator;
+
+pub use public_keys_validator::*;

packages/wasm-dpp/src/identity/validation/public_keys_validator.rs

@@ -0,0 +1,70 @@
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+
+use crate::utils::{to_vec_of_serde_values, ToSerdeJSONExt};
+use crate::validation::ValidationResultWasm;
+use dpp::identity::validation::{
+    PublicKeysValidator, TPublicKeysValidator, PUBLIC_KEY_SCHEMA_FOR_TRANSITION,
+};
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = PublicKeysValidator)]
+pub struct PublicKeysValidatorWasm {
+    public_key_validator: PublicKeysValidator<BlsAdapter>,
+    public_key_in_state_transition_validator: PublicKeysValidator<BlsAdapter>,
+}
+
+#[wasm_bindgen(js_class = PublicKeysValidator)]
+impl PublicKeysValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(adapter: JsBlsAdapter) -> Result<PublicKeysValidatorWasm, JsError> {
+        Ok(Self {
+            public_key_validator: PublicKeysValidator::new(BlsAdapter(JsBlsAdapter::from(
+                adapter.clone(),
+            )))?,
+            public_key_in_state_transition_validator: PublicKeysValidator::new_with_schema(
+                PUBLIC_KEY_SCHEMA_FOR_TRANSITION.clone(),
+                BlsAdapter(adapter),
+            )?,
+        })
+    }
+
+    #[wasm_bindgen(js_name=validateKeys)]
+    pub fn validate_keys(
+        &self,
+        public_keys: js_sys::Array,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
+
+        self.public_key_validator
+            .validate_keys(&raw_public_keys)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name=validatePublicKeyStructure)]
+    pub fn validate_public_key_structure(
+        &self,
+        public_key: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let pk_serde_json = public_key.to_serde_json_value()?;
+
+        self.public_key_validator
+            .validate_public_key_structure(&pk_serde_json)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name=validateKeysInStateTransition)]
+    pub fn validate_keys_in_state_transition(
+        &self,
+        public_keys: js_sys::Array,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
+
+        self.public_key_in_state_transition_validator
+            .validate_keys(&raw_public_keys)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+}

packages/wasm-dpp/src/lib.rs

@@ -4,9 +4,6 @@ pub use dash_platform_protocol::*;
 pub use data_contract::*;
 pub use document::*;
 pub use identity::*;
-pub use identity::*;
-pub use identity_facade::*;
-pub use identity_public_key::*;
 pub use metadata::*;
 
 mod dash_platform_protocol;
@@ -15,12 +12,10 @@ mod document;
 pub mod errors;
 mod identifier;
 mod identity;
-mod identity_facade;
-mod identity_public_key;
 mod metadata;
 
 mod utils;
 
 mod bls_adapter;
 mod buffer;
-pub mod validation_result;
+mod validation;

packages/wasm-dpp/src/validation/mod.rs

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