@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.14

package/src/document/state_transition/document_batch_transition/validation/basic/find_duplicates_by_id.rs

@@ -0,0 +1,40 @@
+use dpp::document::document_transition::{document_base_transition, document_create_transition};
+use dpp::document::validation::basic::find_duplicates_by_id::find_duplicates_by_id;
+use itertools::Itertools;
+use js_sys::Array;
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+use crate::document_batch_transition::document_transition::to_object;
+use crate::utils::{replace_identifiers_with_bytes_without_failing, ToSerdeJSONExt, WithJsError};
+
+#[wasm_bindgen(js_name=findDuplicatesById)]
+pub fn find_duplicates_by_id_wasm(js_raw_transitions: Array) -> Result<Vec<JsValue>, JsValue> {
+    let raw_transitions: Vec<Value> = js_raw_transitions
+        .iter()
+        .map(|t| {
+            t.with_serde_to_json_value().map(|mut v| {
+                replace_identifiers_with_bytes_without_failing(
+                    &mut v,
+                    document_base_transition::IDENTIFIER_FIELDS,
+                );
+                v
+            })
+        })
+        .try_collect()?;
+
+    let result: Vec<JsValue> = find_duplicates_by_id(&raw_transitions)
+        .with_js_error()?
+        .into_iter()
+        .map(|raw| {
+            to_object(
+                raw,
+                &JsValue::null(),
+                document_base_transition::IDENTIFIER_FIELDS,
+                document_create_transition::BINARY_FIELDS,
+            )
+        })
+        .try_collect()?;
+
+    Ok(result)
+}

package/src/document/state_transition/document_batch_transition/validation/basic/find_duplicates_by_indices.rs

@@ -0,0 +1,50 @@
+use dpp::document::{
+    document_transition::{document_base_transition, document_create_transition},
+    validation::basic::find_duplicates_by_indices::find_duplicates_by_indices,
+};
+use itertools::Itertools;
+use js_sys::Array;
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    document_batch_transition::document_transition::to_object,
+    utils::{replace_identifiers_with_bytes_without_failing, ToSerdeJSONExt, WithJsError},
+    DataContractWasm,
+};
+
+#[wasm_bindgen(js_name=findDuplicatesByIndices)]
+pub fn find_duplicates_by_indices_wasm(
+    js_raw_transitions: &Array,
+    data_contract: &DataContractWasm,
+) -> Result<Vec<JsValue>, JsValue> {
+    let raw_transitions: Vec<Value> = js_raw_transitions
+        .iter()
+        .map(|t| {
+            t.with_serde_to_json_value().map(|mut v| {
+                replace_identifiers_with_bytes_without_failing(
+                    &mut v,
+                    document_base_transition::IDENTIFIER_FIELDS,
+                );
+                v
+            })
+        })
+        .try_collect()?;
+
+    let result =
+        find_duplicates_by_indices(&raw_transitions, data_contract.inner()).with_js_error()?;
+
+    let duplicates: Vec<JsValue> = result
+        .into_iter()
+        .map(|v| {
+            to_object(
+                v.to_owned(),
+                &JsValue::NULL,
+                document_base_transition::IDENTIFIER_FIELDS,
+                document_create_transition::BINARY_FIELDS,
+            )
+        })
+        .try_collect()?;
+
+    Ok(duplicates)
+}

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

@@ -0,0 +1,8 @@
+mod find_duplicates_by_id;
+pub use find_duplicates_by_id::*;
+mod find_duplicates_by_indices;
+pub use find_duplicates_by_indices::*;
+mod validate_partial_compound_indices;
+pub use validate_partial_compound_indices::*;
+mod validate_documents_batch_transition_basic;
+pub use validate_documents_batch_transition_basic::*;

package/src/document/state_transition/document_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs

@@ -0,0 +1,34 @@
+use dpp::document::validation::basic::validate_documents_batch_transition_basic;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    utils::{ToSerdeJSONExt, WithJsError},
+    validation::ValidationResultWasm,
+    version::ProtocolVersionValidatorWasm,
+    StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name=validateDocumentsBatchTransitionBasic)]
+pub async fn validate_documents_batch_transition_basic_wasm(
+    protocol_version_validator: ProtocolVersionValidatorWasm,
+    state_repository: ExternalStateRepositoryLike,
+    js_raw_state_transition: JsValue,
+    execution_context: StateTransitionExecutionContextWasm,
+) -> Result<ValidationResultWasm, JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+    let raw_state_transition = js_raw_state_transition.with_serde_to_json_value()?;
+
+    let validation_result =
+        validate_documents_batch_transition_basic::validate_documents_batch_transition_basic(
+            &protocol_version_validator.into(),
+            &raw_state_transition,
+            Arc::new(wrapped_state_repository),
+            &execution_context.into(),
+        )
+        .await
+        .with_js_error()?;
+
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
+}

package/src/document/state_transition/document_batch_transition/validation/basic/validate_partial_compound_indices.rs

@@ -0,0 +1,39 @@
+use dpp::document::{
+    document_transition::document_base_transition,
+    validation::basic::validate_partial_compound_indices::validate_partial_compound_indices,
+};
+use itertools::Itertools;
+use js_sys::Array;
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    utils::{replace_identifiers_with_bytes_without_failing, ToSerdeJSONExt, WithJsError},
+    validation::ValidationResultWasm,
+    DataContractWasm,
+};
+
+#[wasm_bindgen(js_name=validatePartialCompoundIndices)]
+pub fn validate_partial_compound_indices_wasm(
+    js_raw_transitions: Array,
+    data_contract: &DataContractWasm,
+) -> Result<ValidationResultWasm, JsValue> {
+    let raw_transitions: Vec<Value> = js_raw_transitions
+        .iter()
+        .map(|t| {
+            t.with_serde_to_json_value().map(|mut v| {
+                replace_identifiers_with_bytes_without_failing(
+                    &mut v,
+                    document_base_transition::IDENTIFIER_FIELDS,
+                );
+                v
+            })
+        })
+        .try_collect()?;
+
+    let validation_result =
+        validate_partial_compound_indices(&raw_transitions, data_contract.inner())
+            .with_js_error()?;
+
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
+}

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

@@ -0,0 +1,2 @@
+pub mod basic;
+pub mod state;

package/src/document/state_transition/document_batch_transition/validation/state/fetch_documents.rs

@@ -0,0 +1,43 @@
+use dpp::{
+    document::validation::state::fetch_documents, prelude::DocumentTransition,
+    state_transition::state_transition_execution_context::StateTransitionExecutionContext,
+};
+use js_sys::Array;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    document_batch_transition::document_transition::DocumentTransitionWasm,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    utils::{IntoWasm, WithJsError},
+    DocumentWasm, StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name = fetchDocuments)]
+pub async fn fetch_documents_wasm(
+    state_repository: ExternalStateRepositoryLike,
+    js_document_transitions: Array,
+    js_execution_context: &StateTransitionExecutionContextWasm,
+) -> Result<Array, JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+    let mut document_transitions: Vec<DocumentTransition> = vec![];
+    for js_transition in js_document_transitions.iter() {
+        let transition = js_transition.to_wasm::<DocumentTransitionWasm>("DocumentTransition")?;
+        document_transitions.push(transition.to_owned().into());
+    }
+    let execution_context: StateTransitionExecutionContext = js_execution_context.into();
+
+    let documents = fetch_documents::fetch_documents(
+        &wrapped_state_repository,
+        document_transitions,
+        &execution_context,
+    )
+    .await
+    .with_js_error()?;
+
+    let array = js_sys::Array::new();
+    for document in documents.into_iter().map(DocumentWasm::from) {
+        array.push(&document.into());
+    }
+
+    Ok(array)
+}

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

@@ -0,0 +1,3 @@
+pub mod fetch_documents;
+pub mod validate_documents_batch_transitions_state;
+pub mod validate_documents_uniqueness_by_indices;

package/src/document/state_transition/document_batch_transition/validation/state/validate_documents_batch_transitions_state.rs

@@ -0,0 +1,27 @@
+use dpp::document::validation::state::validate_documents_batch_transition_state;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    utils::WithJsError,
+    validation::ValidationResultWasm,
+    DocumentsBatchTransitionWasm,
+};
+
+#[wasm_bindgen(js_name = "validateDocumentsBatchTransitionState")]
+pub async fn validate_documents_batch_transition_state_wasm(
+    state_repository: ExternalStateRepositoryLike,
+    state_transition: &DocumentsBatchTransitionWasm,
+) -> Result<ValidationResultWasm, JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+
+    let validation_result =
+        validate_documents_batch_transition_state::validate_document_batch_transition_state(
+            &wrapped_state_repository,
+            &state_transition.0,
+        )
+        .await
+        .with_js_error()?;
+
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
+}

package/src/document/state_transition/document_batch_transition/validation/state/validate_documents_uniqueness_by_indices.rs

@@ -0,0 +1,47 @@
+use dpp::{
+    document::validation::state::validate_documents_uniqueness_by_indices,
+    prelude::{DocumentTransition, Identifier},
+    state_transition::state_transition_execution_context::StateTransitionExecutionContext,
+};
+use js_sys::Array;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    document_batch_transition::document_transition::DocumentTransitionWasm,
+    identifier::IdentifierWrapper,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    utils::{IntoWasm, WithJsError},
+    validation::ValidationResultWasm,
+    DataContractWasm, StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name=validateDocumentsUniquenessByIndices)]
+pub async fn validate_uniqueness_by_indices_wasm(
+    state_repository: ExternalStateRepositoryLike,
+    js_owner_id: &IdentifierWrapper,
+    js_document_transitions: Array,
+    js_data_contract: &DataContractWasm,
+    js_execution_context: &StateTransitionExecutionContextWasm,
+) -> Result<ValidationResultWasm, JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+    let mut document_transitions: Vec<DocumentTransition> = vec![];
+    for js_transition in js_document_transitions.iter() {
+        let transition = js_transition.to_wasm::<DocumentTransitionWasm>("DocumentTransition")?;
+        document_transitions.push(transition.to_owned().into());
+    }
+    let execution_context: StateTransitionExecutionContext = js_execution_context.into();
+    let owner_id: Identifier = js_owner_id.into();
+
+    let validation_result =
+        validate_documents_uniqueness_by_indices::validate_documents_uniqueness_by_indices(
+            &wrapped_state_repository,
+            &owner_id,
+            document_transitions,
+            js_data_contract.inner(),
+            &execution_context,
+        )
+        .await
+        .with_js_error()?;
+
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
+}

package/src/document/validator.rs

@@ -0,0 +1,52 @@
+use dpp::{document::document_validator::DocumentValidator, version::ProtocolVersionValidator};
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    raw_document_from_js_value, utils::WithJsError, validation::ValidationResultWasm,
+    version::ProtocolVersionValidatorWasm, DataContractWasm,
+};
+
+#[derive(Clone)]
+#[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())))
+    }
+
+    pub fn validate(
+        &self,
+        js_raw_document: &JsValue,
+        js_data_contract: &DataContractWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_document = raw_document_from_js_value(js_raw_document, js_data_contract.inner())?;
+        let validation_result = self
+            .0
+            .validate(&raw_document, js_data_contract.inner())
+            .with_js_error()?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}
+
+impl DocumentValidatorWasm {
+    pub(crate) fn new_with_arc(protocol_validator: Arc<ProtocolVersionValidator>) -> Self {
+        DocumentValidatorWasm(DocumentValidator::new(protocol_validator.clone()))
+    }
+}
+
+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/compatible_protocol_version_is_not_defined_error.rs

@@ -0,0 +1,24 @@
+use dpp::CompatibleProtocolVersionIsNotDefinedError;
+use thiserror::Error;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=CompatibleProtocolVersionIsNotDefinedError)]
+#[derive(Error, Debug)]
+#[error(transparent)]
+pub struct CompatibleProtocolVersionIsNotDefinedErrorWasm(
+    CompatibleProtocolVersionIsNotDefinedError,
+);
+
+impl CompatibleProtocolVersionIsNotDefinedErrorWasm {
+    pub fn new(err: CompatibleProtocolVersionIsNotDefinedError) -> Self {
+        Self(err)
+    }
+}
+
+#[wasm_bindgen(js_class=CompatibleProtocolVersionIsNotDefinedError)]
+impl CompatibleProtocolVersionIsNotDefinedErrorWasm {
+    #[wasm_bindgen(js_name=getCurrentProtocolVersion)]
+    pub fn current_protocol_version(&self) -> u32 {
+        self.0.current_protocol_version()
+    }
+}

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

@@ -16,7 +16,7 @@ impl DuplicateDocumentTransitionsWithIdsErrorWasm {
 
 #[wasm_bindgen(js_class=DuplicateDocumentTransitionsWithIdsError)]
 impl DuplicateDocumentTransitionsWithIdsErrorWasm {
-    #[wasm_bindgen(js_name=getReferences)]
+    #[wasm_bindgen(js_name=getDocumentTransitionReferences)]
     pub fn get_references(&self) -> js_sys::Array {
         self.references
             .iter()

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

@@ -16,7 +16,7 @@ impl DuplicateDocumentTransitionsWithIndicesErrorWasm {
 
 #[wasm_bindgen(js_class=DuplicateDocumentTransitionsWithIndicesError)]
 impl DuplicateDocumentTransitionsWithIndicesErrorWasm {
-    #[wasm_bindgen(js_name=getReferences)]
+    #[wasm_bindgen(js_name=getDocumentTransitionReferences)]
     pub fn get_references(&self) -> js_sys::Array {
         self.references
             .iter()

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

@@ -20,8 +20,8 @@ impl InconsistentCompoundIndexDataErrorWasm {
 
 #[wasm_bindgen(js_class=InconsistentCompoundIndexDataError)]
 impl InconsistentCompoundIndexDataErrorWasm {
-    #[wasm_bindgen(js_name=getIndexProperties)]
-    pub fn get_index_properties(&self) -> js_sys::Array {
+    #[wasm_bindgen(js_name=getIndexedProperties)]
+    pub fn get_indexed_properties(&self) -> js_sys::Array {
         self.index_properties
             .iter()
             .map(|string| JsString::from(string.as_ref()))

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

@@ -2,6 +2,7 @@ use dpp::prelude::Identifier;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
+use crate::identifier::IdentifierWrapper;
 
 #[wasm_bindgen(js_name=InvalidDocumentTypeError)]
 pub struct InvalidDocumentTypeErrorWasm {
@@ -22,7 +23,20 @@ impl InvalidDocumentTypeErrorWasm {
 
 #[wasm_bindgen(js_class=InvalidDocumentTypeError)]
 impl InvalidDocumentTypeErrorWasm {
-    #[wasm_bindgen(js_name=getDocumentType)]
+    #[wasm_bindgen(constructor)]
+    pub fn constructor(
+        document_type: String,
+        data_contract_id: IdentifierWrapper,
+        code: u32,
+    ) -> Self {
+        Self {
+            document_type,
+            data_contract_id: data_contract_id.into(),
+            code,
+        }
+    }
+
+    #[wasm_bindgen(js_name=getType)]
     pub fn get_document_type(&self) -> String {
         self.document_type.clone()
     }

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

@@ -1,13 +1,19 @@
+use dpp::document::document_transition::document_base_transition::JsonValue;
+use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=MissingDataContractIdError)]
 pub struct MissingDataContractIdErrorWasm {
+    raw_document_transition: JsonValue,
     code: u32,
 }
 
 impl MissingDataContractIdErrorWasm {
-    pub fn new(code: u32) -> Self {
-        MissingDataContractIdErrorWasm { code }
+    pub fn new(raw_document_transition: JsonValue, code: u32) -> Self {
+        MissingDataContractIdErrorWasm {
+            raw_document_transition,
+            code,
+        }
     }
 }
 
@@ -17,4 +23,12 @@ impl MissingDataContractIdErrorWasm {
     pub fn get_code(&self) -> u32 {
         self.code
     }
+
+    #[wasm_bindgen(js_name=rawDocumentTransition)]
+    pub fn raw_document_transition(&self) -> wasm_bindgen::JsValue {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        self.raw_document_transition
+            .serialize(&serializer)
+            .expect("implements Serialize")
+    }
 }

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

@@ -21,7 +21,7 @@ impl DuplicatedIdentityPublicKeyErrorWasm {
         self.inner
             .duplicated_public_keys_ids()
             .iter()
-            .map(|id| JsValue::from(*id as u32))
+            .map(|id| JsValue::from(*id))
             .collect()
     }
 

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

@@ -21,7 +21,7 @@ impl DuplicatedIdentityPublicKeyIdErrorWasm {
         self.inner
             .duplicated_ids()
             .iter()
-            .map(|id| JsValue::from(*id as u32))
+            .map(|id| JsValue::from(*id))
             .collect()
     }
 

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

@@ -1,5 +1,6 @@
 use dpp::consensus::basic::identity::IdentityAssetLockProofLockedTransactionMismatchError;
 use dpp::consensus::ConsensusError;
+use dpp::dashcore::hashes::Hash;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -22,13 +23,16 @@ 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())
+        Buffer::from_bytes(&tx_id)
     }
 
     #[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())
+        let mut hash_bytes = tx_id.as_hash().into_inner();
+        hash_bytes.reverse();
+
+        Buffer::from_bytes(&hash_bytes)
     }
 
     #[wasm_bindgen(js_name=getCode)]

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

@@ -1,5 +1,6 @@
 use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutPointAlreadyExistsError;
 use dpp::consensus::ConsensusError;
+use dpp::dashcore::hashes::Hash;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -19,7 +20,7 @@ impl From<&IdentityAssetLockTransactionOutPointAlreadyExistsError>
 
 #[wasm_bindgen(js_class=IdentityAssetLockTransactionOutPointAlreadyExistsError)]
 impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
-    #[wasm_bindgen(js_name=getDuplicatedIds)]
+    #[wasm_bindgen(js_name=getOutputIndex)]
     pub fn output_index(&self) -> usize {
         self.inner.output_index()
     }
@@ -27,7 +28,9 @@ impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
     #[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())
+        let mut tx_id_bytes = tx_id.as_hash().into_inner();
+        tx_id_bytes.reverse();
+        Buffer::from_bytes(&tx_id_bytes)
     }
 
     #[wasm_bindgen(js_name=getCode)]

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

@@ -22,9 +22,9 @@ impl InvalidAssetLockProofTransactionHeightErrorWasm {
         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=getTransactionHeight)]
+    pub fn transaction_height(&self) -> Option<u32> {
+        self.inner.transaction_height()
     }
 
     #[wasm_bindgen(js_name=getCode)]

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

@@ -18,8 +18,8 @@ impl From<&InvalidIdentityCreditWithdrawalTransitionCoreFeeError>
 #[wasm_bindgen(js_class=InvalidIdentityCreditWithdrawalTransitionCoreFeeError)]
 impl InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm {
     #[wasm_bindgen(js_name=getCoreFee)]
-    pub fn core_fee(&self) -> u32 {
-        self.inner.core_fee()
+    pub fn core_fee_per_byte(&self) -> u32 {
+        self.inner.core_fee_per_byte()
     }
 
     #[wasm_bindgen(js_name=getCode)]

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

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

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

@@ -1,13 +1,14 @@
+use dpp::identity::KeyID;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidIdentityKeySignatureError)]
 pub struct InvalidIdentityKeySignatureErrorWasm {
-    public_key_id: u32,
+    public_key_id: KeyID,
     code: u32,
 }
 
 impl InvalidIdentityKeySignatureErrorWasm {
-    pub fn new(public_key_id: u32, code: u32) -> Self {
+    pub fn new(public_key_id: KeyID, code: u32) -> Self {
         InvalidIdentityKeySignatureErrorWasm {
             public_key_id,
             code,
@@ -18,7 +19,7 @@ impl InvalidIdentityKeySignatureErrorWasm {
 #[wasm_bindgen(js_class=InvalidIdentityKeySignatureError)]
 impl InvalidIdentityKeySignatureErrorWasm {
     #[wasm_bindgen(js_name=getPublicKeyId)]
-    pub fn get_public_key_id(&self) -> u32 {
+    pub fn get_public_key_id(&self) -> KeyID {
         self.public_key_id
     }
 

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

@@ -21,7 +21,7 @@ impl InvalidIdentityPublicKeyDataErrorWasm {
     #[wasm_bindgen(js_name=getPublicKeyId)]
     pub fn public_key_id(&self) -> u32 {
         // TODO: think about what to do with that conversion
-        self.inner.public_key_id() as u32
+        self.inner.public_key_id()
     }
 
     #[wasm_bindgen(js_name=getValidationError)]

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

@@ -22,7 +22,7 @@ impl InvalidIdentityPublicKeySecurityLevelErrorWasm {
     #[wasm_bindgen(js_name=getPublicKeyId)]
     pub fn public_key_id(&self) -> u32 {
         // TODO: think about what to do with that conversion
-        self.inner.public_key_id() as u32
+        self.inner.public_key_id()
     }
 
     #[wasm_bindgen(js_name=getPublicKeyPurpose)]