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

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

@@ -0,0 +1,36 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DuplicateIndexNameError)]
+pub struct DuplicateIndexNameErrorWasm {
+    document_type: String,
+    duplicate_index_name: String,
+    code: u32,
+}
+
+impl DuplicateIndexNameErrorWasm {
+    pub fn new(document_type: String, duplicate_index_name: String, code: u32) -> Self {
+        DuplicateIndexNameErrorWasm {
+            document_type,
+            duplicate_index_name,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=DuplicateIndexNameError)]
+impl DuplicateIndexNameErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getDuplicateIndexName)]
+    pub fn get_duplicate_index_name(&self) -> String {
+        self.duplicate_index_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,66 @@
+use crate::buffer::Buffer;
+use dpp::prelude::Identifier;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IncompatibleDataContractSchemaError)]
+pub struct IncompatibleDataContractSchemaErrorWasm {
+    data_contract_id: Identifier,
+    operation: String,
+    field_path: String,
+    old_schema: serde_json::Value,
+    new_schema: serde_json::Value,
+    code: u32,
+}
+
+impl IncompatibleDataContractSchemaErrorWasm {
+    pub fn new(
+        data_contract_id: Identifier,
+        operation: String,
+        field_path: String,
+        old_schema: serde_json::Value,
+        new_schema: serde_json::Value,
+        code: u32,
+    ) -> Self {
+        IncompatibleDataContractSchemaErrorWasm {
+            data_contract_id,
+            operation,
+            field_path,
+            old_schema,
+            new_schema,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=IncompatibleDataContractSchemaError)]
+impl IncompatibleDataContractSchemaErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn get_data_contract_id(&self) -> Buffer {
+        Buffer::from_bytes(self.data_contract_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getOperation)]
+    pub fn get_operation(&self) -> String {
+        self.operation.clone()
+    }
+
+    #[wasm_bindgen(js_name=getFieldPath)]
+    pub fn get_field_path(&self) -> String {
+        self.field_path.clone()
+    }
+
+    #[wasm_bindgen(js_name=getOldSchema)]
+    pub fn get_old_schema(&self) -> Result<JsValue, JsError> {
+        serde_wasm_bindgen::to_value(&self.old_schema).map_err(JsError::from)
+    }
+
+    #[wasm_bindgen(js_name=getNewSchema)]
+    pub fn get_new_schema(&self) -> Result<JsValue, JsError> {
+        serde_wasm_bindgen::to_value(&self.new_schema).map_err(JsError::from)
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,43 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IncompatibleRe2PatternError)]
+pub struct IncompatibleRe2PatternErrorWasm {
+    pattern: String,
+    path: String,
+    message: String,
+    code: u32,
+}
+
+impl IncompatibleRe2PatternErrorWasm {
+    pub fn new(pattern: String, path: String, message: String, code: u32) -> Self {
+        IncompatibleRe2PatternErrorWasm {
+            pattern,
+            path,
+            message,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=IncompatibleRe2PatternError)]
+impl IncompatibleRe2PatternErrorWasm {
+    #[wasm_bindgen(js_name=getPattern)]
+    pub fn get_pattern(&self) -> String {
+        self.pattern.clone()
+    }
+
+    #[wasm_bindgen(js_name=getPath)]
+    pub fn get_path(&self) -> String {
+        self.path.clone()
+    }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn get_message(&self) -> String {
+        self.message.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/index_error/duplicate_index_error.rs

@@ -0,0 +1,39 @@
+use dpp::util::json_schema::Index;
+use wasm_bindgen::prelude::*;
+
+use crate::IndexDefinitionWasm;
+
+#[wasm_bindgen(js_name=DuplicateIndexError)]
+pub struct DuplicateIndexErrorWasm {
+    document_type: String,
+    index_definition: Index,
+    code: u32,
+}
+
+impl DuplicateIndexErrorWasm {
+    pub fn new(document_type: String, index_definition: Index, code: u32) -> Self {
+        DuplicateIndexErrorWasm {
+            document_type,
+            index_definition,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=DuplicateIndexError)]
+impl DuplicateIndexErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexDefinition)]
+    pub fn get_index_definition(&self) -> JsValue {
+        IndexDefinitionWasm::from(self.index_definition.clone()).into()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/index_error/invalid_compound_index_error.rs

@@ -0,0 +1,39 @@
+use dpp::util::json_schema::Index;
+use wasm_bindgen::prelude::*;
+
+use crate::IndexDefinitionWasm;
+
+#[wasm_bindgen(js_name=InvalidCompoundIndexError)]
+pub struct InvalidCompoundIndexErrorWasm {
+    document_type: String,
+    index_definition: Index,
+    code: u32,
+}
+
+impl InvalidCompoundIndexErrorWasm {
+    pub fn new(document_type: String, index_definition: Index, code: u32) -> Self {
+        InvalidCompoundIndexErrorWasm {
+            document_type,
+            index_definition,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidCompoundIndexError)]
+impl InvalidCompoundIndexErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexDefinition)]
+    pub fn get_index_definition(&self) -> JsValue {
+        IndexDefinitionWasm::from(self.index_definition.clone()).into()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/index_error/invalid_index_property_type_error.rs

@@ -0,0 +1,59 @@
+use dpp::util::json_schema::Index;
+use wasm_bindgen::prelude::*;
+
+use crate::IndexDefinitionWasm;
+
+#[wasm_bindgen(js_name=InvalidIndexPropertyTypeError)]
+pub struct InvalidIndexPropertyTypeErrorWasm {
+    document_type: String,
+    index_definition: Index,
+    property_name: String,
+    property_type: String,
+    code: u32,
+}
+
+impl InvalidIndexPropertyTypeErrorWasm {
+    pub fn new(
+        document_type: String,
+        index_definition: Index,
+        property_name: String,
+        property_type: String,
+        code: u32,
+    ) -> Self {
+        InvalidIndexPropertyTypeErrorWasm {
+            document_type,
+            index_definition,
+            property_name,
+            property_type,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIndexPropertyTypeError)]
+impl InvalidIndexPropertyTypeErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexDefinition)]
+    pub fn get_index_definition(&self) -> JsValue {
+        IndexDefinitionWasm::from(self.index_definition.clone()).into()
+    }
+
+    #[wasm_bindgen(js_name=getPropertyName)]
+    pub fn get_property_name(&self) -> String {
+        self.property_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getPropertyType)]
+    pub fn get_property_type(&self) -> String {
+        self.property_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/index_error/invalid_indexed_property_constraint_error.rs

@@ -0,0 +1,67 @@
+use dpp::util::json_schema::Index;
+use wasm_bindgen::prelude::*;
+
+use crate::IndexDefinitionWasm;
+
+#[wasm_bindgen(js_name=InvalidIndexedPropertyConstraintError)]
+pub struct InvalidIndexedPropertyConstraintErrorWasm {
+    document_type: String,
+    index_definition: Index,
+    property_name: String,
+    constraint_name: String,
+    reason: String,
+    code: u32,
+}
+
+impl InvalidIndexedPropertyConstraintErrorWasm {
+    pub fn new(
+        document_type: String,
+        index_definition: Index,
+        property_name: String,
+        constraint_name: String,
+        reason: String,
+        code: u32,
+    ) -> Self {
+        InvalidIndexedPropertyConstraintErrorWasm {
+            document_type,
+            index_definition,
+            property_name,
+            constraint_name,
+            reason,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIndexedPropertyConstraintError)]
+impl InvalidIndexedPropertyConstraintErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexDefinition)]
+    pub fn get_index_definition(&self) -> JsValue {
+        IndexDefinitionWasm::from(self.index_definition.clone()).into()
+    }
+
+    #[wasm_bindgen(js_name=getPropertyName)]
+    pub fn get_property_name(&self) -> String {
+        self.property_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getConstraintName)]
+    pub fn get_constraint_name(&self) -> String {
+        self.constraint_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getReason)]
+    pub fn get_reason(&self) -> String {
+        self.reason.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/index_error/mod.rs

@@ -0,0 +1,15 @@
+mod duplicate_index_error;
+mod invalid_compound_index_error;
+mod invalid_index_property_type_error;
+mod invalid_indexed_property_constraint_error;
+mod system_property_index_already_present_error;
+mod undefined_index_property_error;
+mod unique_indices_limit_reached_error;
+
+pub use duplicate_index_error::*;
+pub use invalid_compound_index_error::*;
+pub use invalid_index_property_type_error::*;
+pub use invalid_indexed_property_constraint_error::*;
+pub use system_property_index_already_present_error::*;
+pub use undefined_index_property_error::*;
+pub use unique_indices_limit_reached_error::*;

package/src/errors/consensus/basic/data_contract/index_error/system_property_index_already_present_error.rs

@@ -0,0 +1,51 @@
+use dpp::util::json_schema::Index;
+use wasm_bindgen::prelude::*;
+
+use crate::IndexDefinitionWasm;
+
+#[wasm_bindgen(js_name=SystemPropertyIndexAlreadyPresentError)]
+pub struct SystemPropertyIndexAlreadyPresentErrorWasm {
+    document_type: String,
+    index_definition: Index,
+    property_name: String,
+    code: u32,
+}
+
+impl SystemPropertyIndexAlreadyPresentErrorWasm {
+    pub fn new(
+        document_type: String,
+        index_definition: Index,
+        property_name: String,
+        code: u32,
+    ) -> Self {
+        SystemPropertyIndexAlreadyPresentErrorWasm {
+            document_type,
+            index_definition,
+            property_name,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=SystemPropertyIndexAlreadyPresentError)]
+impl SystemPropertyIndexAlreadyPresentErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexDefinition)]
+    pub fn get_index_definition(&self) -> JsValue {
+        IndexDefinitionWasm::from(self.index_definition.clone()).into()
+    }
+
+    #[wasm_bindgen(js_name=getPropertyName)]
+    pub fn get_property_name(&self) -> String {
+        self.property_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/index_error/undefined_index_property_error.rs

@@ -0,0 +1,51 @@
+use dpp::util::json_schema::Index;
+use wasm_bindgen::prelude::*;
+
+use crate::IndexDefinitionWasm;
+
+#[wasm_bindgen(js_name=UndefinedIndexPropertyError)]
+pub struct UndefinedIndexPropertyErrorWasm {
+    document_type: String,
+    index_definition: Index,
+    property_name: String,
+    code: u32,
+}
+
+impl UndefinedIndexPropertyErrorWasm {
+    pub fn new(
+        document_type: String,
+        index_definition: Index,
+        property_name: String,
+        code: u32,
+    ) -> Self {
+        UndefinedIndexPropertyErrorWasm {
+            document_type,
+            index_definition,
+            property_name,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=UndefinedIndexPropertyError)]
+impl UndefinedIndexPropertyErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexDefinition)]
+    pub fn get_index_definition(&self) -> JsValue {
+        IndexDefinitionWasm::from(self.index_definition.clone()).into()
+    }
+
+    #[wasm_bindgen(js_name=getPropertyName)]
+    pub fn get_property_name(&self) -> String {
+        self.property_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/index_error/unique_indices_limit_reached_error.rs

@@ -0,0 +1,36 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=UniqueIndicesLimitReachedError)]
+pub struct UniqueIndicesLimitReachedErrorWasm {
+    document_type: String,
+    index_limit: usize,
+    code: u32,
+}
+
+impl UniqueIndicesLimitReachedErrorWasm {
+    pub fn new(document_type: String, index_limit: usize, code: u32) -> Self {
+        UniqueIndicesLimitReachedErrorWasm {
+            document_type,
+            index_limit,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=UniqueIndicesLimitReachedError)]
+impl UniqueIndicesLimitReachedErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexLimit)]
+    pub fn get_index_limit(&self) -> usize {
+        self.index_limit
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,37 @@
+use crate::buffer::Buffer;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidDataContractIdError)]
+pub struct InvalidDataContractIdErrorWasm {
+    expected_id: Vec<u8>,
+    invalid_id: Vec<u8>,
+    code: u32,
+}
+
+impl InvalidDataContractIdErrorWasm {
+    pub fn new(expected_id: Vec<u8>, invalid_id: Vec<u8>, code: u32) -> Self {
+        InvalidDataContractIdErrorWasm {
+            expected_id,
+            invalid_id,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidDataContractIdError)]
+impl InvalidDataContractIdErrorWasm {
+    #[wasm_bindgen(js_name=getExpectedId)]
+    pub fn get_expected_id(&self) -> Buffer {
+        Buffer::from_bytes(&self.expected_id)
+    }
+
+    #[wasm_bindgen(js_name=getInvalidId)]
+    pub fn get_invalid_id(&self) -> Buffer {
+        Buffer::from_bytes(&self.invalid_id)
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,36 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidDataContractVersionError)]
+pub struct InvalidDataContractVersionErrorWasm {
+    expected_version: u32,
+    version: u32,
+    code: u32,
+}
+
+impl InvalidDataContractVersionErrorWasm {
+    pub fn new(expected_version: u32, version: u32, code: u32) -> Self {
+        InvalidDataContractVersionErrorWasm {
+            expected_version,
+            version,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidDataContractVersionError)]
+impl InvalidDataContractVersionErrorWasm {
+    #[wasm_bindgen(js_name=getExpectedVersion)]
+    pub fn get_expected_version(&self) -> u32 {
+        self.expected_version
+    }
+
+    #[wasm_bindgen(js_name=getVersion)]
+    pub fn get_version(&self) -> u32 {
+        self.version
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,26 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidJsonSchemaRefError)]
+pub struct InvalidJsonSchemaRefErrorWasm {
+    ref_error: String,
+    code: u32,
+}
+
+impl InvalidJsonSchemaRefErrorWasm {
+    pub fn new(ref_error: String, code: u32) -> Self {
+        InvalidJsonSchemaRefErrorWasm { ref_error, code }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidJsonSchemaRefError)]
+impl InvalidJsonSchemaRefErrorWasm {
+    #[wasm_bindgen(js_name=getRefError)]
+    pub fn get_ref_error(&self) -> String {
+        self.ref_error.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,25 @@
+mod data_contract_have_new_unique_index_error;
+mod data_contract_immutable_properties_update_error;
+mod data_contract_invalid_index_definition_update_error;
+mod data_contract_max_depth_exceed_error;
+mod data_contract_unique_indices_changed_error;
+mod duplicate_index_name_error;
+mod incompatible_data_contract_schema_error;
+mod incompatible_re2_pattern_error;
+mod index_error;
+mod invalid_data_contract_id_error;
+mod invalid_data_contract_version_error;
+mod invalid_json_schema_ref_error;
+
+pub use data_contract_have_new_unique_index_error::*;
+pub use data_contract_immutable_properties_update_error::*;
+pub use data_contract_invalid_index_definition_update_error::*;
+pub use data_contract_max_depth_exceed_error::*;
+pub use data_contract_unique_indices_changed_error::*;
+pub use duplicate_index_name_error::*;
+pub use incompatible_data_contract_schema_error::*;
+pub use incompatible_re2_pattern_error::*;
+pub use index_error::*;
+pub use invalid_data_contract_id_error::*;
+pub use invalid_data_contract_version_error::*;
+pub use invalid_json_schema_ref_error::*;

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

@@ -0,0 +1,5 @@
+mod protocol_version_parsing_error;
+mod serialized_object_parsing_error;
+
+pub use protocol_version_parsing_error::*;
+pub use serialized_object_parsing_error::*;

package/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs

@@ -0,0 +1,29 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ProtocolVersionParsingError)]
+pub struct ProtocolVersionParsingErrorWasm {
+    parsing_error: JsError,
+    code: u32,
+}
+
+impl ProtocolVersionParsingErrorWasm {
+    pub fn new(parsing_error: JsError, code: u32) -> Self {
+        ProtocolVersionParsingErrorWasm {
+            parsing_error,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=ProtocolVersionParsingError)]
+impl ProtocolVersionParsingErrorWasm {
+    #[wasm_bindgen(js_name=getParsingError)]
+    pub fn get_parsing_error(&self) -> JsError {
+        self.parsing_error.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}