@dashevo/wasm-dpp 0.24.0-dev.11 → 0.24.0-dev.13

package/src/document/state_transition/document_batch_transition/document_transition/mod.rs

@@ -1,14 +1,134 @@
 mod document_create_transition;
 mod document_delete_transition;
-mod document_update_transition;
+mod document_replace_transition;
 
 pub use document_create_transition::*;
 pub use document_delete_transition::*;
-pub use document_update_transition::*;
+pub use document_replace_transition::*;
 
-use dpp::prelude::DocumentTransition;
+use dpp::{
+    document::document_transition::{DocumentTransitionExt, DocumentTransitionObjectLike},
+    prelude::{DocumentTransition, Identifier},
+    util::json_schema::JsonSchemaExt,
+};
+use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
+use crate::{
+    buffer::Buffer, identifier::IdentifierWrapper, utils::WithJsError, with_js_error, BinaryType,
+    DataContractWasm,
+};
+
+#[wasm_bindgen]
+#[derive(Debug, Clone)]
+pub struct DocumentTransitionWasm(DocumentTransition);
+
+#[wasm_bindgen(js_class=DocumentTransitionWasm)]
+impl DocumentTransitionWasm {
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> IdentifierWrapper {
+        self.0.get_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> String {
+        self.0.get_document_type().to_owned()
+    }
+
+    #[wasm_bindgen(js_name=getAction)]
+    pub fn get_action(&self) -> u8 {
+        self.0.get_action().into()
+    }
+
+    #[wasm_bindgen(js_name=getDataContract)]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.0.get_data_contract().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn get_data_contract_id(&self) -> IdentifierWrapper {
+        self.0.get_data_contract_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=get)]
+    pub fn get(&self, path: &str) -> JsValue {
+        let binary_type = self.get_binary_type_of_path(path);
+
+        if let Some(value) = self.0.get_dynamic_property(path) {
+            match binary_type {
+                BinaryType::Identifier => {
+                    if let Ok(bytes) = serde_json::from_value::<Vec<u8>>(value.to_owned()) {
+                        let id: IdentifierWrapper = Identifier::from_bytes(&bytes).unwrap().into();
+
+                        return id.into();
+                    }
+                }
+                BinaryType::Buffer => {
+                    if let Ok(bytes) = serde_json::from_value::<Vec<u8>>(value.to_owned()) {
+                        return Buffer::from_bytes(&bytes).into();
+                    }
+                }
+                BinaryType::None => {
+                    let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+                    if let Ok(js_value) = value.serialize(&serializer) {
+                        return js_value;
+                    }
+                }
+            }
+        }
+
+        JsValue::undefined()
+    }
+
+    #[wasm_bindgen(js_name=getObject)]
+    pub fn to_object(&self, _options: &JsValue) -> Result<JsValue, JsValue> {
+        // TODO options??
+
+        match self.0 {
+            DocumentTransition::Create(ref t) => {
+                DocumentCreateTransitionWasm::from(t.to_owned()).to_object()
+            }
+            DocumentTransition::Replace(ref t) => {
+                DocumentReplaceTransitionWasm::from(t.to_owned()).to_object()
+            }
+            DocumentTransition::Delete(ref t) => {
+                DocumentDeleteTransitionWasm::from(t.to_owned()).to_object()
+            }
+        }
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let json_value = self.0.to_json().with_js_error()?;
+        with_js_error!(json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible()))
+    }
+}
+
+impl DocumentTransitionWasm {
+    fn get_binary_type_of_path(&self, path: impl AsRef<str>) -> BinaryType {
+        let maybe_binary_properties = self
+            .0
+            .get_data_contract()
+            .get_binary_properties(self.0.get_document_type());
+
+        if let Ok(binary_properties) = maybe_binary_properties {
+            if let Some(data) = binary_properties.get(path.as_ref()) {
+                if data.is_type_of_identifier() {
+                    return BinaryType::Identifier;
+                }
+                return BinaryType::Buffer;
+            }
+        }
+        BinaryType::None
+    }
+}
+
+impl From<DocumentTransition> for DocumentTransitionWasm {
+    fn from(v: DocumentTransition) -> Self {
+        DocumentTransitionWasm(v)
+    }
+}
+
 pub fn from_document_transition_to_js_value(document_transition: DocumentTransition) -> JsValue {
     match document_transition {
         DocumentTransition::Create(create_transition) => {

package/src/document/state_transition/document_batch_transition/mod.rs

@@ -1 +1,379 @@
+use dpp::{
+    document::{
+        state_transition::documents_batch_transition::property_names, DocumentsBatchTransition,
+    },
+    prelude::{DataContract, Document, Identifier},
+    state_transition::{
+        state_transition_execution_context::StateTransitionExecutionContext,
+        StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
+        StateTransitionType,
+    },
+    util::json_value::JsonValueExt,
+};
+use js_sys::{Array, Reflect};
+use serde::Serialize;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    bls_adapter::{BlsAdapter, JsBlsAdapter},
+    buffer::Buffer,
+    document_batch_transition::document_transition::DocumentTransitionWasm,
+    identifier::IdentifierWrapper,
+    lodash::lodash_set,
+    utils::{ToSerdeJSONExt, WithJsError},
+    DocumentWasm, IdentityPublicKeyWasm,
+};
 pub mod document_transition;
+
+#[derive(Debug)]
+#[wasm_bindgen(js_name = DocumentsBatchTransition)]
+pub struct DocumentsBatchTransitionWASM(DocumentsBatchTransition);
+
+/// Collections of Documents split by actions
+#[derive(Debug, Default)]
+#[wasm_bindgen(js_name=DocumentsContainer)]
+pub struct DocumentsContainer {
+    create: Vec<Document>,
+    replace: Vec<Document>,
+    delete: Vec<Document>,
+}
+
+#[wasm_bindgen(js_class=DocumentsContainer)]
+impl DocumentsContainer {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    #[wasm_bindgen(js_name=pushDocumentCreate)]
+    pub fn push_document_create(&mut self, d: DocumentWasm) {
+        self.create.push(d.0);
+    }
+
+    #[wasm_bindgen(js_name=pushDocumentReplace)]
+    pub fn push_document_replace(&mut self, d: DocumentWasm) {
+        self.replace.push(d.0);
+    }
+
+    #[wasm_bindgen(js_name=pushDocumentDelete)]
+    pub fn push_document_delete(&mut self, d: DocumentWasm) {
+        self.delete.push(d.0);
+    }
+}
+
+impl DocumentsContainer {
+    pub fn take_documents_create(&mut self) -> Vec<Document> {
+        std::mem::take(&mut self.create)
+    }
+
+    pub fn take_documents_replace(&mut self) -> Vec<Document> {
+        std::mem::take(&mut self.replace)
+    }
+
+    pub fn take_documents_delete(&mut self) -> Vec<Document> {
+        std::mem::take(&mut self.delete)
+    }
+}
+
+#[wasm_bindgen(js_class=DocumentsBatchTransition)]
+impl DocumentsBatchTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn from_raw_object(
+        js_raw_transition: JsValue,
+        data_contracts: Array,
+    ) -> Result<DocumentsBatchTransitionWASM, JsValue> {
+        let data_contracts_array_js = Array::from(&data_contracts);
+
+        let mut data_contracts: Vec<DataContract> = vec![];
+        for contract in data_contracts_array_js.iter() {
+            let json_value = contract.with_serde_to_json_value()?;
+            let data_contract = DataContract::from_json_object(json_value).with_js_error()?;
+            data_contracts.push(data_contract);
+        }
+
+        let documents_batch_transition = DocumentsBatchTransition::from_json_object(
+            js_raw_transition.with_serde_to_json_value()?,
+            data_contracts,
+        )
+        .with_js_error()?;
+
+        Ok(documents_batch_transition.into())
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        StateTransitionType::DocumentsBatch.into()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.get_owner_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getTransitions)]
+    pub fn get_transitions(&self) -> js_sys::Array {
+        let array = js_sys::Array::new();
+        let transitions = self.0.get_transitions();
+
+        for tr in transitions.iter().cloned() {
+            let transition: DocumentTransitionWasm = tr.into();
+            array.push(&transition.into());
+        }
+
+        array
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let value = self.0.to_json(false).with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        let is_null_signature = value.get(property_names::SIGNATURE).is_none();
+        let is_null_signature_public_key_id =
+            value.get(property_names::SIGNATURE_PUBLIC_KEY_ID).is_none();
+
+        let js_value = value.serialize(&serializer)?;
+
+        if is_null_signature {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+        if is_null_signature_public_key_id {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE_PUBLIC_KEY_ID.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+
+        Ok(js_value)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, options: &JsValue) -> Result<JsValue, JsValue> {
+        let skip_signature = if options.is_object() {
+            let options = options.with_serde_to_json_value()?;
+            options.get_bool("skipSignature").unwrap_or_default()
+        } else {
+            false
+        };
+
+        let mut value = self.0.to_object(skip_signature).with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let js_value = value.serialize(&serializer)?;
+
+        // Transform every transition individually
+        let transitions = Array::new();
+        for transition in self.0.transitions.iter() {
+            let js_value =
+                DocumentTransitionWasm::from(transition.to_owned()).to_object(options)?;
+            transitions.push(&js_value);
+        }
+        // Replace the whole collection of transitions
+        Reflect::set(
+            &js_value,
+            &property_names::TRANSITIONS.into(),
+            &transitions.into(),
+        )?;
+
+        // Transform paths that are specific to the DocumentsBatchTransition
+        for path in DocumentsBatchTransition::binary_property_paths() {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let buffer = Buffer::from_bytes(&bytes);
+                lodash_set(&js_value, path, buffer.into());
+            }
+        }
+        for path in DocumentsBatchTransition::identifiers_property_paths() {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let id = IdentifierWrapper::new(bytes)?;
+                lodash_set(&js_value, path, id.into());
+            }
+        }
+
+        if value.get(property_names::SIGNATURE).is_none() && !skip_signature {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+        if value.get(property_names::SIGNATURE_PUBLIC_KEY_ID).is_none() {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE_PUBLIC_KEY_ID.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+
+        Ok(js_value)
+    }
+
+    #[wasm_bindgen(js_name=getModifiedDataIds)]
+    pub fn get_modified_ids(&self) -> Array {
+        let array = Array::new();
+
+        for id in self.0.get_modified_data_ids() {
+            let id = <IdentifierWrapper as From<Identifier>>::from(id.to_owned());
+            array.push(&id.into());
+        }
+
+        array
+    }
+
+    // AbstractSTateTransitionIdentitySigned methods
+    #[wasm_bindgen(js_name=getSignaturePublicKeyId)]
+    pub fn get_signature_public_key_id(&self) -> Option<f64> {
+        self.0.get_signature_public_key_id().map(|v| v as f64)
+    }
+
+    #[wasm_bindgen(js_name=sign)]
+    pub fn sign(
+        &mut self,
+        identity_public_key: &IdentityPublicKeyWasm,
+        private_key: &[u8],
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        self.0
+            .sign(identity_public_key.inner(), private_key, &BlsAdapter(bls))
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=verifyPublicKeyLevelAndPurpose)]
+    pub fn verify_public_key_level_and_purpose(
+        &self,
+        public_key: &IdentityPublicKeyWasm,
+    ) -> Result<(), JsValue> {
+        self.0
+            .verify_public_key_level_and_purpose(public_key.inner())
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=verifyPublicKeyIsEnabled)]
+    pub fn verify_public_key_is_enabled(
+        &self,
+        public_key: &IdentityPublicKeyWasm,
+    ) -> Result<(), JsValue> {
+        self.0
+            .verify_public_key_is_enabled(public_key.inner())
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=verifySignature)]
+    pub fn verify_signature(
+        &self,
+        public_key: &IdentityPublicKeyWasm,
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        self.0
+            .verify_signature(public_key.inner(), &BlsAdapter(bls))
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=setSignaturePublicKey)]
+    pub fn set_signature_public_key(&mut self, key_id: u64) {
+        self.0.set_signature_public_key_id(key_id)
+    }
+
+    #[wasm_bindgen(js_name=getSecurityLevelRequirement)]
+    pub fn get_security_level_requirement(&self) -> u8 {
+        self.0.get_security_level_requirement().into()
+    }
+
+    // AbstractStateTransition methods
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.get_protocol_version()
+    }
+
+    #[wasm_bindgen(js_name=getSignature)]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.get_signature().to_owned()
+    }
+
+    #[wasm_bindgen(js_name=setSignature)]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature(signature)
+    }
+
+    #[wasm_bindgen(js_name=calculateFee)]
+    pub fn calculate_fee(&self) -> i64 {
+        self.0.calculate_fee()
+    }
+
+    #[wasm_bindgen(js_name=isDocumentStateTransition)]
+    pub fn is_document_state_transition(&self) -> bool {
+        self.0.is_document_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isDataContractStateTransition)]
+    pub fn is_data_contract_state_transition(&self) -> bool {
+        self.0.is_data_contract_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isIdentityStateTransition)]
+    pub fn is_identity_state_transition(&self) -> bool {
+        self.0.is_identity_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=setExecutionContext)]
+    pub fn set_execution_context(&mut self, context: StateExecutionContext) {
+        self.0.set_execution_context(context.into_inner());
+    }
+
+    #[wasm_bindgen(js_name=getExecutionContext)]
+    pub fn get_execution_context(&mut self) -> StateExecutionContext {
+        StateExecutionContext(self.0.get_execution_context().to_owned())
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self, options: &JsValue) -> Result<Buffer, JsValue> {
+        let skip_signature = if options.is_object() {
+            let options = options.with_serde_to_json_value()?;
+            options.get_bool("skipSignature").unwrap_or_default()
+        } else {
+            false
+        };
+        let bytes = self.0.to_buffer(skip_signature).with_js_error()?;
+
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self, options: JsValue) -> Result<Buffer, JsValue> {
+        let skip_signature = if options.is_object() {
+            let options = options.with_serde_to_json_value()?;
+            options.get_bool("skipSignature").unwrap_or_default()
+        } else {
+            false
+        };
+        let bytes = self.0.hash(skip_signature).with_js_error()?;
+
+        Ok(Buffer::from_bytes(&bytes))
+    }
+}
+
+#[wasm_bindgen(js_name=StateExecutionContext)]
+pub struct StateExecutionContext(StateTransitionExecutionContext);
+
+impl StateExecutionContext {
+    pub fn into_inner(self) -> StateTransitionExecutionContext {
+        self.0
+    }
+
+    pub fn inner(&self) -> &StateTransitionExecutionContext {
+        &self.0
+    }
+
+    pub fn inner_mut(&mut self) -> &mut StateTransitionExecutionContext {
+        &mut self.0
+    }
+}
+
+impl From<DocumentsBatchTransition> for DocumentsBatchTransitionWASM {
+    fn from(t: DocumentsBatchTransition) -> Self {
+        DocumentsBatchTransitionWASM(t)
+    }
+}

package/src/document/validator.rs

@@ -0,0 +1,30 @@
+use std::sync::Arc;
+
+use dpp::document::document_validator::DocumentValidator;
+
+use wasm_bindgen::prelude::*;
+
+use crate::version::ProtocolVersionValidatorWasm;
+
+#[wasm_bindgen(js_name = DocumentValidator)]
+pub struct DocumentValidatorWasm(DocumentValidator);
+
+#[wasm_bindgen(js_class=DocumentValidator)]
+impl DocumentValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(protocol_validator: ProtocolVersionValidatorWasm) -> DocumentValidatorWasm {
+        DocumentValidatorWasm(DocumentValidator::new(Arc::new(protocol_validator.into())))
+    }
+}
+
+impl From<DocumentValidator> for DocumentValidatorWasm {
+    fn from(doc_validator: DocumentValidator) -> Self {
+        DocumentValidatorWasm(doc_validator)
+    }
+}
+
+impl From<DocumentValidatorWasm> for DocumentValidator {
+    fn from(val: DocumentValidatorWasm) -> Self {
+        val.0
+    }
+}

package/src/errors/consensus/basic/data_contract/data_contract_max_depth_exceed_error.rs

@@ -1,19 +1,19 @@
 use wasm_bindgen::prelude::*;
 
-#[wasm_bindgen(js_name=DataContractMaxDepthError)]
-pub struct DataContractMaxDepthErrorWasm {
+#[wasm_bindgen(js_name=DataContractMaxDepthExceedError)]
+pub struct DataContractMaxDepthExceedErrorWasm {
     depth: usize,
     code: u32,
 }
 
-impl DataContractMaxDepthErrorWasm {
+impl DataContractMaxDepthExceedErrorWasm {
     pub fn new(depth: usize, code: u32) -> Self {
-        DataContractMaxDepthErrorWasm { depth, code }
+        DataContractMaxDepthExceedErrorWasm { depth, code }
     }
 }
 
 #[wasm_bindgen(js_class=DataContractMaxDepthError)]
-impl DataContractMaxDepthErrorWasm {
+impl DataContractMaxDepthExceedErrorWasm {
     #[wasm_bindgen(js_name=getDepth)]
     pub fn get_expected_version(&self) -> usize {
         self.depth

package/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs

@@ -3,19 +3,19 @@ use std::iter::FromIterator;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DuplicateDocumentTransitionsWithIdsError)]
-pub struct DuplicateDocumentTransitionsWithIdsError {
+pub struct DuplicateDocumentTransitionsWithIdsErrorWasm {
     references: Vec<(String, Vec<u8>)>,
     code: u32,
 }
 
-impl DuplicateDocumentTransitionsWithIdsError {
+impl DuplicateDocumentTransitionsWithIdsErrorWasm {
     pub fn new(references: Vec<(String, Vec<u8>)>, code: u32) -> Self {
-        DuplicateDocumentTransitionsWithIdsError { references, code }
+        DuplicateDocumentTransitionsWithIdsErrorWasm { references, code }
     }
 }
 
 #[wasm_bindgen(js_class=DuplicateDocumentTransitionsWithIdsError)]
-impl DuplicateDocumentTransitionsWithIdsError {
+impl DuplicateDocumentTransitionsWithIdsErrorWasm {
     #[wasm_bindgen(js_name=getReferences)]
     pub fn get_references(&self) -> js_sys::Array {
         self.references

package/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs

@@ -0,0 +1,36 @@
+use crate::buffer::Buffer;
+use std::iter::FromIterator;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DuplicateDocumentTransitionsWithIndicesError)]
+pub struct DuplicateDocumentTransitionsWithIndicesErrorWasm {
+    references: Vec<(String, Vec<u8>)>,
+    code: u32,
+}
+
+impl DuplicateDocumentTransitionsWithIndicesErrorWasm {
+    pub fn new(references: Vec<(String, Vec<u8>)>, code: u32) -> Self {
+        DuplicateDocumentTransitionsWithIndicesErrorWasm { references, code }
+    }
+}
+
+#[wasm_bindgen(js_class=DuplicateDocumentTransitionsWithIndicesError)]
+impl DuplicateDocumentTransitionsWithIndicesErrorWasm {
+    #[wasm_bindgen(js_name=getReferences)]
+    pub fn get_references(&self) -> js_sys::Array {
+        self.references
+            .iter()
+            .map(|v| {
+                js_sys::Array::from_iter(vec![
+                    JsValue::from(v.0.clone()),
+                    JsValue::from(Buffer::from_bytes(&v.1)),
+                ])
+            })
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/document/missing_document_transition_type_error.rs

@@ -0,0 +1,20 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=MissingDocumentTransitionTypeError)]
+pub struct MissingDocumentTransitionTypeErrorWasm {
+    code: u32,
+}
+
+impl MissingDocumentTransitionTypeErrorWasm {
+    pub fn new(code: u32) -> Self {
+        MissingDocumentTransitionTypeErrorWasm { code }
+    }
+}
+
+#[wasm_bindgen(js_class=MissingDocumentTransitionTypeError)]
+impl MissingDocumentTransitionTypeErrorWasm {
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/document/mod.rs

@@ -1,19 +1,23 @@
 mod data_contract_not_present_error;
 mod duplicate_document_transitions_with_ids_error;
+mod duplicate_document_transitions_with_indices_error;
 mod inconsistent_compound_index_data_error;
 mod invalid_document_transition_action_error;
 mod invalid_document_transition_id_error;
 mod invalid_document_type_error;
 mod missing_data_contract_id_error;
 mod missing_document_transition_action_error;
+mod missing_document_transition_type_error;
 mod missing_document_type_error;
 
 pub use data_contract_not_present_error::*;
 pub use duplicate_document_transitions_with_ids_error::*;
+pub use duplicate_document_transitions_with_indices_error::*;
 pub use inconsistent_compound_index_data_error::*;
 pub use invalid_document_transition_action_error::*;
 pub use invalid_document_transition_id_error::*;
 pub use invalid_document_type_error::*;
 pub use missing_data_contract_id_error::*;
 pub use missing_document_transition_action_error::*;
+pub use missing_document_transition_type_error::*;
 pub use missing_document_type_error::*;

package/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()
     }