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

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

@@ -0,0 +1,29 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=SerializedObjectParsingError)]
+pub struct SerializedObjectParsingErrorWasm {
+    parsing_error: JsError,
+    code: u32,
+}
+
+impl SerializedObjectParsingErrorWasm {
+    pub fn new(parsing_error: JsError, code: u32) -> Self {
+        SerializedObjectParsingErrorWasm {
+            parsing_error,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=SerializedObjectParsingError)]
+impl SerializedObjectParsingErrorWasm {
+    #[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
+    }
+}

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

@@ -0,0 +1,32 @@
+use dpp::prelude::Identifier;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+
+#[wasm_bindgen(js_name=DataContractNotPresentError)]
+pub struct DataContractNotPresentErrorWasm {
+    data_contract_id: Identifier,
+    code: u32,
+}
+
+impl DataContractNotPresentErrorWasm {
+    pub fn new(data_contract_id: Identifier, code: u32) -> Self {
+        DataContractNotPresentErrorWasm {
+            data_contract_id,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractNotPresentError)]
+impl DataContractNotPresentErrorWasm {
+    #[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=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,36 @@
+use crate::buffer::Buffer;
+use std::iter::FromIterator;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DuplicateDocumentTransitionsWithIdsError)]
+pub struct DuplicateDocumentTransitionsWithIdsError {
+    references: Vec<(String, Vec<u8>)>,
+    code: u32,
+}
+
+impl DuplicateDocumentTransitionsWithIdsError {
+    pub fn new(references: Vec<(String, Vec<u8>)>, code: u32) -> Self {
+        DuplicateDocumentTransitionsWithIdsError { references, code }
+    }
+}
+
+#[wasm_bindgen(js_class=DuplicateDocumentTransitionsWithIdsError)]
+impl DuplicateDocumentTransitionsWithIdsError {
+    #[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/inconsistent_compound_index_data_error.rs

@@ -0,0 +1,40 @@
+use js_sys::JsString;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InconsistentCompoundIndexDataError)]
+pub struct InconsistentCompoundIndexDataErrorWasm {
+    index_properties: Vec<String>,
+    document_type: String,
+    code: u32,
+}
+
+impl InconsistentCompoundIndexDataErrorWasm {
+    pub fn new(index_properties: Vec<String>, document_type: String, code: u32) -> Self {
+        InconsistentCompoundIndexDataErrorWasm {
+            index_properties,
+            document_type,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InconsistentCompoundIndexDataError)]
+impl InconsistentCompoundIndexDataErrorWasm {
+    #[wasm_bindgen(js_name=getIndexProperties)]
+    pub fn get_index_properties(&self) -> js_sys::Array {
+        self.index_properties
+            .iter()
+            .map(|string| JsString::from(string.as_ref()))
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,26 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidDocumentTransitionActionError)]
+pub struct InvalidDocumentTransitionActionErrorWasm {
+    action: String,
+    code: u32,
+}
+
+impl InvalidDocumentTransitionActionErrorWasm {
+    pub fn new(action: String, code: u32) -> Self {
+        InvalidDocumentTransitionActionErrorWasm { action, code }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidDocumentTransitionActionError)]
+impl InvalidDocumentTransitionActionErrorWasm {
+    #[wasm_bindgen(js_name=getAction)]
+    pub fn get_action(&self) -> String {
+        self.action.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,38 @@
+use crate::buffer::Buffer;
+use dpp::prelude::Identifier;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidDocumentTransitionIdError)]
+pub struct InvalidDocumentTransitionIdErrorWasm {
+    expected_id: Identifier,
+    invalid_id: Identifier,
+    code: u32,
+}
+
+impl InvalidDocumentTransitionIdErrorWasm {
+    pub fn new(expected_id: Identifier, invalid_id: Identifier, code: u32) -> Self {
+        InvalidDocumentTransitionIdErrorWasm {
+            expected_id,
+            invalid_id,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidDocumentTransitionIdError)]
+impl InvalidDocumentTransitionIdErrorWasm {
+    #[wasm_bindgen(js_name=getExpectedId)]
+    pub fn get_expected_id(&self) -> Buffer {
+        Buffer::from_bytes(self.expected_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getInvalidId)]
+    pub fn get_invalid_id(&self) -> Buffer {
+        Buffer::from_bytes(self.invalid_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,39 @@
+use dpp::prelude::Identifier;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+
+#[wasm_bindgen(js_name=InvalidDocumentTypeError)]
+pub struct InvalidDocumentTypeErrorWasm {
+    document_type: String,
+    data_contract_id: Identifier,
+    code: u32,
+}
+
+impl InvalidDocumentTypeErrorWasm {
+    pub fn new(document_type: String, data_contract_id: Identifier, code: u32) -> Self {
+        InvalidDocumentTypeErrorWasm {
+            document_type,
+            data_contract_id,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidDocumentTypeError)]
+impl InvalidDocumentTypeErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[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=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+mod data_contract_not_present_error;
+mod duplicate_document_transitions_with_ids_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_type_error;
+
+pub use data_contract_not_present_error::*;
+pub use duplicate_document_transitions_with_ids_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_type_error::*;

package/src/errors/consensus/basic/identity/duplicated_identity_public_key_error.rs

@@ -0,0 +1,32 @@
+use dpp::consensus::basic::identity::DuplicatedIdentityPublicKeyError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DuplicatedIdentityPublicKeyError)]
+pub struct DuplicatedIdentityPublicKeyErrorWasm {
+    inner: DuplicatedIdentityPublicKeyError,
+}
+
+impl From<&DuplicatedIdentityPublicKeyError> for DuplicatedIdentityPublicKeyErrorWasm {
+    fn from(e: &DuplicatedIdentityPublicKeyError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=DuplicatedIdentityPublicKeyError)]
+impl DuplicatedIdentityPublicKeyErrorWasm {
+    #[wasm_bindgen(js_name=getDuplicatedPublicKeysIds)]
+    pub fn duplicated_public_keys_ids(&self) -> Vec<u32> {
+        // TODO: key ids probably should be u32
+        self.inner
+            .duplicated_public_keys_ids()
+            .iter()
+            .map(|id| *id as u32)
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

package/src/errors/consensus/basic/identity/duplicated_identity_public_key_id_error.rs

@@ -0,0 +1,32 @@
+use dpp::consensus::basic::identity::DuplicatedIdentityPublicKeyIdError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DuplicatedIdentityPublicKeyIdError)]
+pub struct DuplicatedIdentityPublicKeyIdErrorWasm {
+    inner: DuplicatedIdentityPublicKeyIdError,
+}
+
+impl From<&DuplicatedIdentityPublicKeyIdError> for DuplicatedIdentityPublicKeyIdErrorWasm {
+    fn from(e: &DuplicatedIdentityPublicKeyIdError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=DuplicatedIdentityPublicKeyIdError)]
+impl DuplicatedIdentityPublicKeyIdErrorWasm {
+    #[wasm_bindgen(js_name=getDuplicatedIds)]
+    pub fn duplicated_ids(&self) -> Vec<u32> {
+        // TODO: key ids probably should be u32
+        self.inner
+            .duplicated_ids()
+            .iter()
+            .map(|id| *id as u32)
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

package/src/errors/consensus/basic/identity/identity_asset_lock_proof_locked_transaction_mismatch_error.rs

@@ -0,0 +1,38 @@
+use dpp::consensus::basic::identity::IdentityAssetLockProofLockedTransactionMismatchError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+
+#[wasm_bindgen(js_name=IdentityAssetLockProofLockedTransactionMismatchError)]
+pub struct IdentityAssetLockProofLockedTransactionMismatchErrorWasm {
+    inner: IdentityAssetLockProofLockedTransactionMismatchError,
+}
+
+impl From<&IdentityAssetLockProofLockedTransactionMismatchError>
+    for IdentityAssetLockProofLockedTransactionMismatchErrorWasm
+{
+    fn from(e: &IdentityAssetLockProofLockedTransactionMismatchError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityAssetLockProofLockedTransactionMismatchError)]
+impl IdentityAssetLockProofLockedTransactionMismatchErrorWasm {
+    #[wasm_bindgen(js_name=getInstantLockTransactionId)]
+    pub fn instant_lock_transaction_id(&self) -> Buffer {
+        let tx_id = self.inner.instant_lock_transaction_id();
+        Buffer::from_bytes(tx_id.to_vec().as_ref())
+    }
+
+    #[wasm_bindgen(js_name=getAssetLockTransactionId)]
+    pub fn asset_lock_transaction_id(&self) -> Buffer {
+        let tx_id = self.inner.asset_lock_transaction_id();
+        Buffer::from_bytes(tx_id.to_vec().as_ref())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

package/src/errors/consensus/basic/identity/identity_asset_lock_transaction_is_not_found_error.rs

@@ -0,0 +1,31 @@
+use dpp::consensus::basic::identity::IdentityAssetLockTransactionIsNotFoundError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+
+#[wasm_bindgen(js_name=IdentityAssetLockTransactionIsNotFoundError)]
+pub struct IdentityAssetLockTransactionIsNotFoundErrorWasm {
+    inner: IdentityAssetLockTransactionIsNotFoundError,
+}
+
+impl From<&IdentityAssetLockTransactionIsNotFoundError>
+    for IdentityAssetLockTransactionIsNotFoundErrorWasm
+{
+    fn from(e: &IdentityAssetLockTransactionIsNotFoundError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityAssetLockTransactionIsNotFoundError)]
+impl IdentityAssetLockTransactionIsNotFoundErrorWasm {
+    #[wasm_bindgen(js_name=getTransactionId)]
+    pub fn transaction_id(&self) -> Buffer {
+        Buffer::from_bytes(self.inner.transaction_id())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

package/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_already_exists_error.rs

@@ -0,0 +1,37 @@
+use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutPointAlreadyExistsError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+
+#[wasm_bindgen(js_name=IdentityAssetLockTransactionOutPointAlreadyExistsError)]
+pub struct IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
+    inner: IdentityAssetLockTransactionOutPointAlreadyExistsError,
+}
+
+impl From<&IdentityAssetLockTransactionOutPointAlreadyExistsError>
+    for IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm
+{
+    fn from(e: &IdentityAssetLockTransactionOutPointAlreadyExistsError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityAssetLockTransactionOutPointAlreadyExistsError)]
+impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
+    #[wasm_bindgen(js_name=getDuplicatedIds)]
+    pub fn output_index(&self) -> usize {
+        self.inner.output_index()
+    }
+
+    #[wasm_bindgen(js_name=getTransactionId)]
+    pub fn transaction_id(&self) -> Buffer {
+        let tx_id = self.inner.transaction_id();
+        Buffer::from_bytes(tx_id.to_vec().as_ref())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

package/src/errors/consensus/basic/identity/identity_asset_lock_transaction_output_not_found_error.rs

@@ -0,0 +1,29 @@
+use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutputNotFoundError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IdentityAssetLockTransactionOutputNotFoundError)]
+pub struct IdentityAssetLockTransactionOutputNotFoundErrorWasm {
+    inner: IdentityAssetLockTransactionOutputNotFoundError,
+}
+
+impl From<&IdentityAssetLockTransactionOutputNotFoundError>
+    for IdentityAssetLockTransactionOutputNotFoundErrorWasm
+{
+    fn from(e: &IdentityAssetLockTransactionOutputNotFoundError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityAssetLockTransactionOutputNotFoundError)]
+impl IdentityAssetLockTransactionOutputNotFoundErrorWasm {
+    #[wasm_bindgen(js_name=getOutputIndex)]
+    pub fn output_index(&self) -> usize {
+        self.inner.output_index()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

package/src/errors/consensus/basic/identity/identity_insufficient_balance_error.rs

@@ -0,0 +1,33 @@
+use crate::buffer::Buffer;
+use dpp::consensus::basic::identity::IdentityInsufficientBalanceError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IdentityInsufficientBalanceError)]
+pub struct IdentityInsufficientBalanceErrorWasm {
+    inner: IdentityInsufficientBalanceError,
+}
+
+impl From<&IdentityInsufficientBalanceError> for IdentityInsufficientBalanceErrorWasm {
+    fn from(e: &IdentityInsufficientBalanceError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityInsufficientBalanceError)]
+impl IdentityInsufficientBalanceErrorWasm {
+    #[wasm_bindgen(js_name=getIdentityId)]
+    pub fn identity_id(&self) -> Buffer {
+        Buffer::from_bytes(self.inner.identity_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getBalance)]
+    pub fn balance(&self) -> u32 {
+        self.inner.balance() as u32
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

package/src/errors/consensus/basic/identity/invalid_asset_lock_proof_core_chain_height_error.rs

@@ -0,0 +1,34 @@
+use dpp::consensus::basic::identity::InvalidAssetLockProofCoreChainHeightError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidAssetLockProofCoreChainHeightError)]
+pub struct InvalidAssetLockProofCoreChainHeightErrorWasm {
+    inner: InvalidAssetLockProofCoreChainHeightError,
+}
+
+impl From<&InvalidAssetLockProofCoreChainHeightError>
+    for InvalidAssetLockProofCoreChainHeightErrorWasm
+{
+    fn from(e: &InvalidAssetLockProofCoreChainHeightError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidAssetLockProofCoreChainHeightError)]
+impl InvalidAssetLockProofCoreChainHeightErrorWasm {
+    #[wasm_bindgen(js_name=getProofCoreChainLockedHeight)]
+    pub fn proof_core_chain_locked_height(&self) -> u32 {
+        self.inner.proof_core_chain_locked_height()
+    }
+
+    #[wasm_bindgen(js_name=getCurrentCoreChainLockedHeight)]
+    pub fn current_core_chain_locked_height(&self) -> u32 {
+        self.inner.current_core_chain_locked_height()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

package/src/errors/consensus/basic/identity/invalid_asset_lock_proof_transaction_height_error.rs

@@ -0,0 +1,34 @@
+use dpp::consensus::basic::identity::InvalidAssetLockProofTransactionHeightError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidAssetLockProofTransactionHeightError)]
+pub struct InvalidAssetLockProofTransactionHeightErrorWasm {
+    inner: InvalidAssetLockProofTransactionHeightError,
+}
+
+impl From<&InvalidAssetLockProofTransactionHeightError>
+    for InvalidAssetLockProofTransactionHeightErrorWasm
+{
+    fn from(e: &InvalidAssetLockProofTransactionHeightError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidAssetLockProofTransactionHeightError)]
+impl InvalidAssetLockProofTransactionHeightErrorWasm {
+    #[wasm_bindgen(js_name=getProofCoreChainLockedHeight)]
+    pub fn proof_core_chain_locked_height(&self) -> u32 {
+        self.inner.proof_core_chain_locked_height()
+    }
+
+    #[wasm_bindgen(js_name=getCurrentCoreChainLockedHeight)]
+    pub fn current_core_chain_locked_height(&self) -> Option<u32> {
+        self.inner.current_core_chain_locked_height()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

package/src/errors/consensus/basic/identity/invalid_asset_lock_transaction_output_return_size_error.rs

@@ -0,0 +1,29 @@
+use dpp::consensus::basic::identity::InvalidAssetLockTransactionOutputReturnSizeError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidAssetLockTransactionOutputReturnSizeError)]
+pub struct InvalidAssetLockTransactionOutputReturnSizeErrorWasm {
+    inner: InvalidAssetLockTransactionOutputReturnSizeError,
+}
+
+impl From<&InvalidAssetLockTransactionOutputReturnSizeError>
+    for InvalidAssetLockTransactionOutputReturnSizeErrorWasm
+{
+    fn from(e: &InvalidAssetLockTransactionOutputReturnSizeError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidAssetLockTransactionOutputReturnSizeError)]
+impl InvalidAssetLockTransactionOutputReturnSizeErrorWasm {
+    #[wasm_bindgen(js_name=getOutputIndex)]
+    pub fn output_index(&self) -> usize {
+        self.inner.output_index()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}