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

package/src/errors/mod.rs

@@ -0,0 +1,10 @@
+pub use from::*;
+pub use js_conversion::*;
+
+pub mod consensus;
+pub mod consensus_error;
+mod from;
+mod js_conversion;
+mod public_key_validation_error;
+
+pub use public_key_validation_error::*;

package/src/errors/public_key_validation_error.rs

@@ -0,0 +1,23 @@
+use dpp::PublicKeyValidationError;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=PublicKeyValidationError)]
+#[derive(Clone, Debug)]
+pub struct PublicKeyValidationErrorWasm {
+    inner: PublicKeyValidationError,
+}
+
+impl From<PublicKeyValidationError> for PublicKeyValidationErrorWasm {
+    fn from(e: PublicKeyValidationError) -> Self {
+        Self { inner: e }
+    }
+}
+
+#[wasm_bindgen(js_class=PublicKeyValidationError)]
+impl PublicKeyValidationErrorWasm {
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> JsValue {
+        self.inner.message().into()
+    }
+}

package/src/identifier.rs

@@ -0,0 +1,103 @@
+pub use serde::{Deserialize, Serialize};
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+
+use crate::buffer::Buffer;
+use crate::errors::from_dpp_err;
+use dpp::identifier;
+
+#[derive(Serialize, Deserialize, PartialEq, Eq)]
+enum IdentifierSource {
+    String(String),
+    Buffer(Vec<u8>),
+}
+
+#[wasm_bindgen]
+extern "C" {
+    fn alert(s: &str);
+
+    #[wasm_bindgen(js_namespace = console, js_name=log)]
+    fn log(a: &str);
+}
+
+#[wasm_bindgen(js_name=Identifier, inspectable)]
+pub struct IdentifierWrapper {
+    wrapped: identifier::Identifier,
+}
+
+impl std::convert::From<identifier::Identifier> for IdentifierWrapper {
+    fn from(s: identifier::Identifier) -> Self {
+        IdentifierWrapper { wrapped: s }
+    }
+}
+
+#[wasm_bindgen(js_class=Identifier)]
+impl IdentifierWrapper {
+    #[wasm_bindgen(constructor)]
+    pub fn new(buffer: Vec<u8>) -> Result<IdentifierWrapper, JsValue> {
+        // TODO: remove unwrap
+        let identifier = identifier::Identifier::from_bytes(&buffer).map_err(from_dpp_err)?;
+
+        Ok(IdentifierWrapper {
+            wrapped: identifier,
+        })
+    }
+
+    pub fn from(value: JsValue, encoding: Option<String>) -> Result<IdentifierWrapper, JsValue> {
+        if value.is_string() {
+            let string = value.as_string().unwrap();
+            Ok(IdentifierWrapper::from_string(string, encoding))
+        } else if value.has_type::<js_sys::Uint8Array>() {
+            let vec = value.dyn_into::<js_sys::Uint8Array>()?.to_vec();
+            IdentifierWrapper::new(vec)
+        } else {
+            Err(JsValue::from(
+                "Identifier.from received an unexpected value",
+            ))
+        }
+    }
+
+    #[wasm_bindgen(js_name=fromString)]
+    pub fn from_string(value: String, encoding: Option<String>) -> IdentifierWrapper {
+        // TODO: remove unwrap
+        let identifier = identifier::Identifier::from_string_with_encoding_string(
+            &value[..],
+            encoding.as_deref(),
+        )
+        .unwrap();
+
+        IdentifierWrapper {
+            wrapped: identifier,
+        }
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self) -> Buffer {
+        Buffer::from_bytes(self.wrapped.buffer.as_slice())
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> String {
+        self.to_string(None)
+    }
+
+    #[wasm_bindgen(js_name=toString)]
+    pub fn to_string(&self, encoding: Option<String>) -> String {
+        // Converting string to a string slice. Rust interfaces work
+        // with immutable string slices more often, while js interop accepts mutable String.
+        // as_deref dereferences value in the Option
+        // dereferencing is accessing the underlying value of the reference, which in
+        // case of the string would be a string slice
+        self.wrapped
+            .to_string_with_encoding_string(encoding.as_deref())
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn length(&self) -> usize {
+        self.wrapped.buffer.len()
+    }
+
+    pub fn inner(&self) -> Vec<u8> {
+        self.wrapped.buffer.to_vec()
+    }
+}

package/src/identity.rs

@@ -0,0 +1,253 @@
+use js_sys::Array;
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
+use dpp::identity::IdentityPublicKey;
+use dpp::identity::{Identity, KeyID};
+use dpp::metadata::Metadata;
+use dpp::{ProtocolError, SerdeParsingError};
+
+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;
+
+#[wasm_bindgen(js_name=Identity)]
+#[derive(Clone)]
+pub struct IdentityWasm(Identity);
+
+#[wasm_bindgen(js_name=AssetLockProof)]
+pub struct AssetLockProofWasm(AssetLockProof);
+impl From<AssetLockProof> for AssetLockProofWasm {
+    fn from(v: AssetLockProof) -> Self {
+        AssetLockProofWasm(v)
+    }
+}
+
+#[wasm_bindgen(js_class=Identity)]
+impl IdentityWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_identity: JsValue) -> Result<IdentityWasm, JsValue> {
+        let identity_json = utils::stringify(&raw_identity)?;
+        let raw_identity: Value =
+            serde_json::from_str(&identity_json).map_err(|e| e.to_string())?;
+
+        let identity = Identity::from_json_object(raw_identity).unwrap();
+        Ok(IdentityWasm(identity))
+    }
+
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.get_protocol_version()
+    }
+
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> IdentifierWrapper {
+        self.0.get_id().clone().into()
+    }
+
+    #[wasm_bindgen(js_name=setPublicKeys)]
+    pub fn set_public_keys(&mut self, public_keys: js_sys::Array) -> Result<usize, JsValue> {
+        let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
+        if raw_public_keys.is_empty() {
+            return Err(format!("Setting public keys failed. The input ('{}') is invalid. You must use array of PublicKeys", public_keys.to_string()).into());
+        }
+
+        let public_keys = raw_public_keys
+            .into_iter()
+            .map(IdentityPublicKey::from_json_object)
+            .collect::<Result<_, _>>()
+            .map_err(|e| {
+                format!(
+                    "converting to collection of IdentityPublicKeys failed: {:#}",
+                    e
+                )
+            })?;
+
+        self.0.set_public_keys(public_keys);
+
+        Ok(self.0.get_public_keys().len())
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeys)]
+    pub fn get_public_keys(&self) -> Vec<JsValue> {
+        self.0
+            .get_public_keys()
+            .iter()
+            .map(IdentityPublicKey::to_owned)
+            .map(IdentityPublicKeyWasm::from)
+            .map(JsValue::from)
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeyById)]
+    pub fn get_public_key_by_id(&self, key_id: u32) -> Option<IdentityPublicKeyWasm> {
+        let key_id = key_id as KeyID;
+        self.0
+            .get_public_key_by_id(key_id)
+            .map(IdentityPublicKey::to_owned)
+            .map(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=getBalance)]
+    pub fn get_balance(&self) -> f64 {
+        self.0.get_balance() as f64
+    }
+
+    #[wasm_bindgen(js_name=setBalance)]
+    pub fn set_balance(&mut self, balance: f64) {
+        self.0.set_balance(balance as u64);
+    }
+
+    #[wasm_bindgen(js_name=increaseBalance)]
+    pub fn increase_balance(&mut self, amount: f64) -> f64 {
+        self.0.increase_balance(amount as u64) as f64
+    }
+
+    #[wasm_bindgen(js_name=reduceBalance)]
+    pub fn reduce_balance(&mut self, amount: f64) -> f64 {
+        self.0.reduce_balance(amount as u64) as f64
+    }
+
+    #[wasm_bindgen(js_name=setAssetLockProof)]
+    pub fn set_asset_lock_proof(&mut self, lock: JsValue) {
+        self.0
+            .set_asset_lock_proof(serde_wasm_bindgen::from_value(lock).unwrap());
+    }
+
+    #[wasm_bindgen(js_name=getAssetLockProof)]
+    pub fn get_asset_lock_proof(&self) -> Option<AssetLockProofWasm> {
+        self.0
+            .get_asset_lock_proof()
+            .map(AssetLockProof::to_owned)
+            .map(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=setRevision)]
+    pub fn set_revision(&mut self, revision: f64) {
+        self.0.set_revision(revision as u64);
+    }
+
+    #[wasm_bindgen(js_name=getRevision)]
+    pub fn get_revision(&self) -> f64 {
+        self.0.get_revision() as f64
+    }
+
+    #[wasm_bindgen(js_name=setMetadata)]
+    pub fn set_metadata(&mut self, metadata: MetadataWasm) {
+        self.0.set_metadata(metadata.into());
+    }
+
+    #[wasm_bindgen(js_name=getMetadata)]
+    pub fn get_metadata(&self) -> Option<MetadataWasm> {
+        self.0
+            .get_metadata()
+            .map(Metadata::to_owned)
+            .map(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=from)]
+    pub fn from(object: JsValue) -> Self {
+        let i: Identity = serde_json::from_str(&object.as_string().unwrap()).unwrap();
+        IdentityWasm(i)
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let pks = self
+            .0
+            .public_keys
+            .iter()
+            .map(|pk| pk.to_json())
+            .collect::<Result<Vec<serde_json::Value>, SerdeParsingError>>()
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        let mut identity_json =
+            serde_json::to_value(self.0.clone()).map_err(|e| from_dpp_err(e.into()))?;
+
+        let map = identity_json.as_object_mut().ok_or_else(|| {
+            from_dpp_err(ProtocolError::Generic(
+                "Expect identity to be a json map".into(),
+            ))
+        })?;
+        map.insert("publicKeys".into(), serde_json::Value::from(pks));
+
+        let identity_json_string =
+            serde_json::to_string(&identity_json).map_err(|e| from_dpp_err(e.into()))?;
+
+        js_sys::JSON::parse(&identity_json_string)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, _some_option: Option<bool>) -> Result<JsValue, JsValue> {
+        let js_public_keys = js_sys::Array::new();
+        for pk in self.0.public_keys.iter() {
+            let pk_wasm = IdentityPublicKeyWasm::from(pk.to_owned());
+            js_public_keys.push(&pk_wasm.to_object(None)?);
+        }
+
+        let identity_json =
+            serde_json::to_value(self.0.clone()).map_err(|e| from_dpp_err(e.into()))?;
+        let identity_json_string =
+            serde_json::to_string(&identity_json).map_err(|e| from_dpp_err(e.into()))?;
+        let js_object = js_sys::JSON::parse(&identity_json_string)?;
+
+        let id: IdentifierWrapper = self.0.id.clone().into();
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"id".to_owned().into(),
+            &JsValue::from(id.to_buffer()),
+        )?;
+        js_sys::Reflect::set(
+            &js_object,
+            &"publicKeys".to_owned().into(),
+            &JsValue::from(&js_public_keys),
+        )?;
+
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self) -> Vec<u8> {
+        self.0.to_buffer().unwrap()
+    }
+
+    #[wasm_bindgen]
+    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.hash().map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=addPublicKey)]
+    pub fn add_public_key(&mut self, public_key: IdentityPublicKeyWasm) {
+        self.0.public_keys.push(public_key.into());
+    }
+
+    // The method `addPublicKeys()` takes an variadic array of `IdentityPublicKeyWasm` as an input. But elements of the array
+    // are available ONLY as `JsValue`. WASM-bindgen uses output from `toJSON()` to store WASM-object as `JsValue`.
+    // `toJSON()` converts binary data to `base64` or `base58`. Therefore we need to use `from_json_object()` constructor to
+    // to convert strings back into bytes and get `IdentityPublicKeyWasm`
+    #[wasm_bindgen(js_name=addPublicKeys, variadic)]
+    pub fn add_public_keys(&mut self, js_public_keys: JsValue) -> Result<(), JsValue> {
+        let js_public_keys_array = Array::from(&js_public_keys);
+        let json_objects = to_vec_of_serde_values(js_public_keys_array.iter())?;
+
+        let public_keys: Vec<IdentityPublicKey> = json_objects
+            .into_iter()
+            .map(IdentityPublicKey::from_json_object)
+            .collect::<Result<Vec<IdentityPublicKey>, ProtocolError>>()
+            .map_err(from_dpp_err)?;
+
+        self.0
+            .add_public_keys(public_keys.into_iter().map(Into::into));
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeyMaxId)]
+    pub fn get_public_ke_max_id(&self) -> f64 {
+        self.0.get_public_key_max_id() as f64
+    }
+}

package/src/identity_facade.rs

@@ -0,0 +1,55 @@
+use std::sync::Arc;
+
+use wasm_bindgen::prelude::*;
+
+use dpp::identity::validation::PublicKeysValidator;
+use dpp::identity::IdentityFacade;
+
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::validation_result::ValidationResultWasm;
+use dpp::version::ProtocolVersionValidator;
+use dpp::NonConsensusError;
+
+#[wasm_bindgen(js_name=IdentityFacade)]
+pub struct IdentityFacadeWasm(IdentityFacade<BlsAdapter>);
+
+#[wasm_bindgen(js_class=IdentityFacade)]
+impl IdentityFacadeWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(bls_adapter: JsBlsAdapter) -> IdentityFacadeWasm {
+        let bls = BlsAdapter(bls_adapter);
+        // TODO: REMOVE THAT LINE, TAKE IT AS AN ARGUMENT
+        let protocol_version_validator = ProtocolVersionValidator::default();
+        let public_keys_validator = PublicKeysValidator::new(bls).unwrap();
+        let identity_facade = IdentityFacade::new(
+            Arc::new(protocol_version_validator),
+            Arc::new(public_keys_validator),
+        )
+        .unwrap();
+
+        IdentityFacadeWasm(identity_facade)
+    }
+
+    #[wasm_bindgen()]
+    pub fn validate(
+        &self,
+        raw_identity_object: JsValue,
+    ) -> Result<ValidationResultWasm, NonConsensusErrorWasm> {
+        let identity_json = serde_wasm_bindgen::from_value(raw_identity_object)
+            .expect("unable to serialize identity");
+        // TODO: handle the case when
+        self.0
+            .validate(&identity_json)
+            .map(|res| res.into())
+            .map_err(|err| err.into())
+    }
+}
+
+#[wasm_bindgen(js_name=NonConsensusErrorWasm)]
+pub struct NonConsensusErrorWasm(NonConsensusError);
+
+impl From<NonConsensusError> for NonConsensusErrorWasm {
+    fn from(err: NonConsensusError) -> Self {
+        Self(err)
+    }
+}

package/src/identity_public_key/key_type.rs

@@ -0,0 +1,22 @@
+use dpp::identity::KeyType;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=KeyType)]
+#[allow(non_camel_case_types)]
+pub enum KeyTypeWasm {
+    ECDSA_SECP256K1 = 0,
+    BLS12_381 = 1,
+    ECDSA_HASH160 = 2,
+    BIP13_SCRIPT_HASH = 3,
+}
+
+impl From<KeyType> for KeyTypeWasm {
+    fn from(key_type: KeyType) -> Self {
+        match key_type {
+            KeyType::ECDSA_SECP256K1 => Self::ECDSA_SECP256K1,
+            KeyType::BLS12_381 => Self::BLS12_381,
+            KeyType::ECDSA_HASH160 => Self::ECDSA_HASH160,
+            KeyType::BIP13_SCRIPT_HASH => Self::BIP13_SCRIPT_HASH,
+        }
+    }
+}

package/src/identity_public_key/mod.rs

@@ -0,0 +1,192 @@
+use dpp::dashcore::anyhow;
+pub use serde::{Deserialize, Serialize};
+use std::convert::{TryFrom, TryInto};
+use wasm_bindgen::prelude::*;
+
+use crate::errors::from_dpp_err;
+use crate::{buffer::Buffer, utils};
+use dpp::identity::IdentityPublicKey;
+
+mod purpose;
+pub use purpose::*;
+
+mod security_level;
+pub use security_level::*;
+
+mod key_type;
+mod public_keys_validator;
+
+pub use public_keys_validator::*;
+
+pub use key_type::*;
+
+#[wasm_bindgen(js_name=IdentityPublicKey)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct IdentityPublicKeyWasm(IdentityPublicKey);
+
+#[wasm_bindgen(js_class = IdentityPublicKey)]
+impl IdentityPublicKeyWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_public_key: JsValue) -> Result<IdentityPublicKeyWasm, JsValue> {
+        let data_string = utils::stringify(&raw_public_key)?;
+        let pk: IdentityPublicKeyWasm =
+            serde_json::from_str(&data_string).map_err(|e| e.to_string())?;
+
+        Ok(pk)
+    }
+
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> u32 {
+        self.0.get_id() as u32
+    }
+
+    #[wasm_bindgen(js_name=setId)]
+    pub fn set_id(&mut self, id: u32) {
+        self.0.set_id(id.into());
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        self.0.get_type() as u8
+    }
+
+    #[wasm_bindgen(js_name=setType)]
+    pub fn set_type(&mut self, key_type: u8) -> Result<(), JsValue> {
+        self.0.set_type(
+            key_type
+                .try_into()
+                .map_err(|e: anyhow::Error| e.to_string())?,
+        );
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=setData)]
+    pub fn set_data(&mut self, data: Vec<u8>) -> Result<(), JsValue> {
+        self.0.set_data(data);
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getData)]
+    pub fn get_data(&self) -> Vec<u8> {
+        self.0.get_data().to_vec()
+    }
+
+    #[wasm_bindgen(js_name=setPurpose)]
+    pub fn set_purpose(&mut self, purpose: u8) -> Result<(), JsValue> {
+        self.0.set_purpose(
+            purpose
+                .try_into()
+                .map_err(|e: anyhow::Error| e.to_string())?,
+        );
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getPurpose)]
+    pub fn get_purpose(&self) -> u8 {
+        self.0.get_purpose() as u8
+    }
+
+    #[wasm_bindgen(js_name=setSecurityLevel)]
+    pub fn set_security_level(&mut self, purpose: u8) -> Result<(), JsValue> {
+        self.0.set_security_level(
+            purpose
+                .try_into()
+                .map_err(|e: anyhow::Error| e.to_string())?,
+        );
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getSecurityLevel)]
+    pub fn get_security_level(&self) -> u8 {
+        self.0.get_security_level() as u8
+    }
+
+    #[wasm_bindgen(js_name=setReadOnly)]
+    pub fn set_readonly(&mut self, purpose: bool) {
+        self.0.set_readonly(purpose);
+    }
+
+    #[wasm_bindgen(js_name=isReadOnly)]
+    pub fn is_readonly(&self) -> bool {
+        self.0.get_readonly()
+    }
+
+    #[wasm_bindgen(js_name=setDisabledAt)]
+    pub fn set_disabled_at(&mut self, timestamp: u32) {
+        self.0.set_disabled_at(timestamp as u64);
+    }
+
+    #[wasm_bindgen(js_name=getDisabledAt)]
+    pub fn get_disabled_at(&self) -> Option<u32> {
+        self.0.get_disabled_at().map(|timestamp| timestamp as u32)
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.hash().map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=isMaster)]
+    pub fn is_master(&self) -> bool {
+        self.0.is_master()
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let val = self.0.to_json().map_err(|e| from_dpp_err(e.into()))?;
+        let json = val.to_string();
+        js_sys::JSON::parse(&json)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, some_option: Option<bool>) -> Result<JsValue, JsValue> {
+        let val = self
+            .0
+            .to_raw_json_object(some_option.unwrap_or(false))
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        let data_buffer = Buffer::from_bytes(self.0.get_data());
+        let signature_buffer = Buffer::from_bytes(self.0.get_signature());
+
+        let json = val.to_string();
+        let js_object = js_sys::JSON::parse(&json)?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"data".to_owned().into(),
+            &JsValue::from(data_buffer),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"signature".to_owned().into(),
+            &JsValue::from(signature_buffer),
+        )?;
+
+        Ok(js_object)
+    }
+}
+
+impl From<IdentityPublicKey> for IdentityPublicKeyWasm {
+    fn from(v: IdentityPublicKey) -> Self {
+        IdentityPublicKeyWasm(v)
+    }
+}
+
+impl TryFrom<JsValue> for IdentityPublicKeyWasm {
+    type Error = JsValue;
+
+    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        let str = String::from(js_sys::JSON::stringify(&value)?);
+        let val = serde_json::from_str(&str).map_err(|e| from_dpp_err(e.into()))?;
+        Ok(Self(
+            IdentityPublicKey::from_raw_object(val).map_err(from_dpp_err)?,
+        ))
+    }
+}
+
+impl From<IdentityPublicKeyWasm> for IdentityPublicKey {
+    fn from(pk: IdentityPublicKeyWasm) -> Self {
+        pk.0
+    }
+}

package/src/identity_public_key/public_keys_validator.rs

@@ -0,0 +1,44 @@
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+
+use crate::utils::{to_vec_of_serde_values, ToSerdeJSONExt};
+use crate::validation_result::ValidationResultWasm;
+use dpp::identity::validation::{PublicKeysValidator, TPublicKeysValidator};
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = PublicKeysValidator)]
+pub struct PublicKeysValidatorWasm(PublicKeysValidator<BlsAdapter>);
+
+#[wasm_bindgen(js_class = PublicKeysValidator)]
+impl PublicKeysValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(adapter: JsBlsAdapter) -> PublicKeysValidatorWasm {
+        Self(PublicKeysValidator::new(BlsAdapter(adapter)).unwrap())
+    }
+
+    #[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.0
+            .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.0
+            .validate_public_key_structure(&pk_serde_json)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+}