@dashevo/wasm-dpp 0.25.0-dev.15 → 0.25.0-dev.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.25.0-dev.15",
+  "version": "0.25.0-dev.16",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,9 +43,9 @@
     "@babel/cli": "^7.21.0",
     "@babel/core": "^7.15.5",
     "@babel/preset-env": "^7.15.4",
-    "@dashevo/dashcore-lib": "~0.20.6",
-    "@dashevo/dpns-contract": "0.25.0-dev.15",
-    "@dashevo/dpp": "0.25.0-dev.15",
+    "@dashevo/dashcore-lib": "~0.20.9",
+    "@dashevo/dpns-contract": "0.25.0-dev.16",
+    "@dashevo/dpp": "0.25.0-dev.16",
     "@dashevo/wasm-re2": "~1.0.2",
     "@types/bs58": "^4.0.1",
     "@types/node": "^14.6.0",

package/scripts/build-wasm.sh

@@ -14,7 +14,6 @@ if [[ "${CARGO_BUILD_PROFILE}" == "dev" ]]; then
 fi
 
 OUTPUT_DIR="${PWD}/wasm"
-WORKSPACE_ROOT="$(dirname "$0")/../../.."
 # shellcheck disable=SC2034
 OUTPUT_FILE="${OUTPUT_DIR}/wasm_dpp_bg.wasm"
 BUILD_COMMAND="cargo build --config net.git-fetch-with-cli=true --target=${TARGET} ${PROFILE_ARG}"
@@ -24,15 +23,13 @@ if ! [[ -d ${OUTPUT_DIR} ]]; then
   mkdir -p "${OUTPUT_DIR}"
 fi
 
-if ! [[ -x "$(command -v cargo-lock)" ]]; then
-  echo 'cargo-lock is not installed. Installing'
-  cargo install cargo-lock --features=cli --profile "${CARGO_BUILD_PROFILE}"
-fi
-
-WASM_BINDGEN_VERSION=$(cargo-lock list --file "${WORKSPACE_ROOT}/Cargo.lock" --package wasm-bindgen | grep -Eo '[0-9.]+')
-if ! [[ "$(wasm-bindgen --version)" =~ ${WASM_BINDGEN_VERSION} ]]; then
+# TODO: Build wasm with build.rs
+# Meantime if you want to update wasm-bindgen you also need to update version in:
+#  - packages/wasm-dpp/Cargo.toml
+#  - Dockerfile
+if ! [[ -x "$(command -v wasm-bindgen)" ]]; then
   echo "Wasm-bindgen CLI ${WASM_BINDGEN_VERSION} is not installed. Installing"
-  cargo install --config net.git-fetch-with-cli=true --profile "${CARGO_BUILD_PROFILE}" -f "wasm-bindgen-cli@${WASM_BINDGEN_VERSION}"
+  cargo install --config net.git-fetch-with-cli=true --profile "${CARGO_BUILD_PROFILE}" -f "wasm-bindgen-cli@0.2.86"
 fi
 
 # On a mac, bundled clang won't work - you need to install LLVM manually through brew,

package/src/data_contract/data_contract.rs

@@ -327,6 +327,18 @@ impl DataContractWasm {
         Ok(object)
     }
 
+    #[wasm_bindgen(js_name=getConfig)]
+    pub fn config(&self) -> Result<JsValue, JsValue> {
+        Ok(serde_wasm_bindgen::to_value(&self.inner.config)?)
+    }
+
+    #[wasm_bindgen(js_name=setConfig)]
+    pub fn set_config(&mut self, config: JsValue) -> Result<(), JsValue> {
+        let res = serde_wasm_bindgen::from_value(config);
+        self.inner.config = res.unwrap();
+        Ok(())
+    }
+
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
         let json = self.inner.to_json().with_js_error()?;

package/src/data_contract/state_transition/data_contract_create_transition/mod.rs

@@ -8,7 +8,7 @@ pub use validation::*;
 
 use dpp::consensus::signature::SignatureError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization_traits::{PlatformDeserializable, PlatformSerializable};
 use dpp::state_transition::StateTransition;
 use dpp::{
     data_contract::state_transition::data_contract_create_transition::DataContractCreateTransition,
@@ -77,6 +77,13 @@ impl DataContractCreateTransitionWasm {
         self.0.data_contract.clone().into()
     }
 
+    #[wasm_bindgen(js_name=setDataContractConfig)]
+    pub fn set_data_contract_config(&mut self, config: JsValue) -> Result<(), JsValue> {
+        let res = serde_wasm_bindgen::from_value(config);
+        self.0.data_contract.config = res.unwrap();
+        Ok(())
+    }
+
     #[wasm_bindgen(js_name=getProtocolVersion)]
     pub fn get_protocol_version(&self) -> u32 {
         self.0.protocol_version
@@ -116,6 +123,16 @@ impl DataContractCreateTransitionWasm {
         Ok(Buffer::from_bytes(&bytes))
     }
 
+    #[wasm_bindgen(js_name=fromBuffer)]
+    pub fn from_buffer(buffer: Vec<u8>) -> Result<DataContractCreateTransitionWasm, JsValue> {
+        let state_transition: StateTransition =
+            PlatformDeserializable::deserialize(&buffer).with_js_error()?;
+        match state_transition {
+            StateTransition::DataContractCreate(dct) => Ok(dct.into()),
+            _ => Err(JsValue::from_str("Invalid state transition type")),
+        }
+    }
+
     #[wasm_bindgen(js_name=getModifiedDataIds)]
     pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
         self.0

package/src/data_contract/state_transition/data_contract_update_transition/mod.rs

@@ -7,7 +7,7 @@ pub use apply::*;
 pub use validation::*;
 
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization_traits::{PlatformDeserializable, PlatformSerializable};
 use dpp::state_transition::StateTransition;
 use dpp::{
     consensus::signature::SignatureError,
@@ -79,6 +79,13 @@ impl DataContractUpdateTransitionWasm {
         self.0.data_contract.clone().into()
     }
 
+    #[wasm_bindgen(js_name=setDataContractConfig)]
+    pub fn set_data_contract_config(&mut self, config: JsValue) -> Result<(), JsValue> {
+        let res = serde_wasm_bindgen::from_value(config);
+        self.0.data_contract.config = res.unwrap();
+        Ok(())
+    }
+
     #[wasm_bindgen(js_name=getProtocolVersion)]
     pub fn get_protocol_version(&self) -> u32 {
         self.0.protocol_version
@@ -113,6 +120,16 @@ impl DataContractUpdateTransitionWasm {
         Ok(Buffer::from_bytes(&bytes))
     }
 
+    #[wasm_bindgen(js_name=fromBuffer)]
+    pub fn from_buffer(buffer: Vec<u8>) -> Result<DataContractUpdateTransitionWasm, JsValue> {
+        let state_transition: StateTransition =
+            PlatformDeserializable::deserialize(&buffer).with_js_error()?;
+        match state_transition {
+            StateTransition::DataContractUpdate(dct) => Ok(dct.into()),
+            _ => Err(JsValue::from_str("Invalid state transition type")),
+        }
+    }
+
     #[wasm_bindgen(js_name=getModifiedDataIds)]
     pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
         self.0

package/src/data_contract_factory/data_contract_factory.rs

@@ -14,7 +14,7 @@ use dpp::{
 use wasm_bindgen::prelude::*;
 
 use crate::entropy_generator::ExternalEntropyGenerator;
-use crate::utils::WithJsError;
+use crate::utils::{ToSerdeJSONExt, WithJsError};
 
 use crate::{
     data_contract::errors::InvalidDataContractError,
@@ -106,15 +106,24 @@ impl DataContractFactoryWasm {
         &self,
         owner_id: Vec<u8>,
         documents: JsValue,
+        config: JsValue,
     ) -> Result<DataContractWasm, JsValue> {
         let documents_object: platform_value::Value =
             with_js_error!(serde_wasm_bindgen::from_value(documents))?;
+
+        let contract_config = if config.is_object() && !config.is_falsy() {
+            let raw_config = config.with_serde_to_json_value()?;
+            Some(serde_json::from_value(raw_config).with_js_error()?)
+        } else {
+            None
+        };
+
         let identifier = Identifier::from_bytes(&owner_id)
             .map_err(ProtocolError::ValueError)
             .with_js_error()?;
         //todo: contract config
         self.0
-            .create(identifier, documents_object, None, None)
+            .create(identifier, documents_object, contract_config, None)
             .map(Into::into)
             .with_js_error()
     }

package/src/errors/consensus/consensus_error.rs

@@ -74,7 +74,10 @@ use crate::errors::consensus::signature::{
 use crate::errors::consensus::state::data_contract::data_trigger::{
     DataTriggerConditionErrorWasm, DataTriggerExecutionErrorWasm,
 };
-use crate::errors::consensus::state::data_contract::DataContractAlreadyPresentErrorWasm;
+use crate::errors::consensus::state::data_contract::{
+    DataContractAlreadyPresentErrorWasm, DataContractConfigUpdateErrorWasm,
+    DataContractIsReadonlyErrorWasm,
+};
 use crate::errors::consensus::state::document::{
     DocumentAlreadyPresentErrorWasm, DocumentNotFoundErrorWasm, DocumentOwnerIdMismatchErrorWasm,
     DocumentTimestampWindowViolationErrorWasm, DocumentTimestampsMismatchErrorWasm,
@@ -202,6 +205,12 @@ pub fn from_state_error(state_error: &StateError) -> JsValue {
         StateError::DocumentTimestampsAreEqualError(e) => {
             DocumentTimestampsAreEqualErrorWasm::from(e).into()
         }
+        StateError::DataContractIsReadonlyError(e) => {
+            DataContractIsReadonlyErrorWasm::from(e).into()
+        }
+        StateError::DataContractConfigUpdateError(e) => {
+            DataContractConfigUpdateErrorWasm::from(e).into()
+        }
     }
 }
 

package/src/errors/consensus/state/data_contract/data_contract_config_update_error.rs

@@ -0,0 +1,53 @@
+use crate::buffer::Buffer;
+use crate::identifier::IdentifierWrapper;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::state::data_contract::data_contract_config_update_error::DataContractConfigUpdateError;
+use dpp::consensus::ConsensusError;
+
+use dpp::serialization_traits::PlatformSerializable;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractConfigUpdateError)]
+pub struct DataContractConfigUpdateErrorWasm {
+    inner: DataContractConfigUpdateError,
+}
+
+impl From<&DataContractConfigUpdateError> for DataContractConfigUpdateErrorWasm {
+    fn from(e: &DataContractConfigUpdateError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractConfigUpdateError)]
+impl DataContractConfigUpdateErrorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(data_contract_id: IdentifierWrapper, message: String) -> Self {
+        Self {
+            inner: DataContractConfigUpdateError::new(data_contract_id.into(), message),
+        }
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> IdentifierWrapper {
+        self.inner.data_contract_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+
+    #[wasm_bindgen(js_name=serialize)]
+    pub fn serialize(&self) -> Result<Buffer, JsError> {
+        let bytes = ConsensusError::from(self.inner.clone())
+            .serialize()
+            .map_err(JsError::from)?;
+
+        Ok(Buffer::from_bytes(bytes.as_slice()))
+    }
+}

package/src/errors/consensus/state/data_contract/data_contract_is_readonly_error.rs

@@ -0,0 +1,53 @@
+use crate::buffer::Buffer;
+use crate::identifier::IdentifierWrapper;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::state::data_contract::data_contract_is_readonly_error::DataContractIsReadonlyError;
+use dpp::consensus::ConsensusError;
+
+use dpp::serialization_traits::PlatformSerializable;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractIsReadonlyError)]
+pub struct DataContractIsReadonlyErrorWasm {
+    inner: DataContractIsReadonlyError,
+}
+
+impl From<&DataContractIsReadonlyError> for DataContractIsReadonlyErrorWasm {
+    fn from(e: &DataContractIsReadonlyError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractIsReadonlyError)]
+impl DataContractIsReadonlyErrorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(data_contract_id: IdentifierWrapper) -> Self {
+        Self {
+            inner: DataContractIsReadonlyError::new(data_contract_id.into()),
+        }
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> IdentifierWrapper {
+        self.inner.data_contract_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+
+    #[wasm_bindgen(js_name=serialize)]
+    pub fn serialize(&self) -> Result<Buffer, JsError> {
+        let bytes = ConsensusError::from(self.inner.clone())
+            .serialize()
+            .map_err(JsError::from)?;
+
+        Ok(Buffer::from_bytes(bytes.as_slice()))
+    }
+}

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

@@ -1,4 +1,8 @@
 mod data_contract_already_present_error;
+mod data_contract_config_update_error;
+mod data_contract_is_readonly_error;
 pub mod data_trigger;
 
 pub use data_contract_already_present_error::*;
+pub use data_contract_config_update_error::*;
+pub use data_contract_is_readonly_error::*;

package/src/errors/consensus/state/document/document_timestamps_are_equal_error.rs

@@ -36,7 +36,7 @@ impl DocumentTimestampsAreEqualErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/identity/identity_facade.rs

@@ -17,8 +17,9 @@ use crate::utils::{ToSerdeJSONExt, WithJsError};
 use crate::validation::ValidationResultWasm;
 use crate::{
     create_asset_lock_proof_from_wasm_instance, with_js_error, ChainAssetLockProofWasm,
-    IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm,
-    IdentityWasm, InstantAssetLockProofWasm,
+    IdentityCreateTransitionWasm, IdentityCreditTransferTransitionWasm,
+    IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm, IdentityWasm,
+    InstantAssetLockProofWasm,
 };
 use dpp::dashcore::{consensus, InstantLock, Transaction};
 
@@ -191,6 +192,23 @@ impl IdentityFacadeWasm {
             .with_js_error()
     }
 
+    #[wasm_bindgen(js_name=createIdentityCreditTransferTransition)]
+    pub fn create_identity_credit_transfer_transition(
+        &self,
+        identity_id: &IdentifierWrapper,
+        recipient_id: &IdentifierWrapper,
+        amount: u64,
+    ) -> Result<IdentityCreditTransferTransitionWasm, JsValue> {
+        self.0
+            .create_identity_credit_transfer_transition(
+                identity_id.to_owned().into(),
+                recipient_id.to_owned().into(),
+                amount,
+            )
+            .map(Into::into)
+            .with_js_error()
+    }
+
     #[wasm_bindgen(js_name=createIdentityUpdateTransition)]
     pub fn create_identity_update_transition(
         &self,

package/src/identity/identity_factory.rs

@@ -7,8 +7,9 @@ use crate::identity::validation::IdentityValidatorWasm;
 
 use crate::{
     create_asset_lock_proof_from_wasm_instance, with_js_error, ChainAssetLockProofWasm,
-    IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm,
-    IdentityWasm, InstantAssetLockProofWasm,
+    IdentityCreateTransitionWasm, IdentityCreditTransferTransitionWasm,
+    IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm, IdentityWasm,
+    InstantAssetLockProofWasm,
 };
 use dpp::dashcore::{consensus, InstantLock, Transaction};
 use dpp::identity::factory::IdentityFactory;
@@ -177,6 +178,23 @@ impl IdentityFactoryWasm {
             .with_js_error()
     }
 
+    #[wasm_bindgen(js_name=createIdentityCreditTransferTransition)]
+    pub fn create_identity_credit_transfer_transition(
+        &self,
+        identity_id: &IdentifierWrapper,
+        recipient_id: &IdentifierWrapper,
+        amount: u64,
+    ) -> Result<IdentityCreditTransferTransitionWasm, JsValue> {
+        self.0
+            .create_identity_credit_transfer_transition(
+                identity_id.to_owned().into(),
+                recipient_id.to_owned().into(),
+                amount,
+            )
+            .map(Into::into)
+            .with_js_error()
+    }
+
     #[wasm_bindgen(js_name=createIdentityUpdateTransition)]
     pub fn create_identity_update_transition(
         &self,

package/src/identity/state_transition/identity_credit_transfer_transition/apply_identity_credit_transfer_transition.rs

@@ -0,0 +1,31 @@
+use dpp::identity::state_transition::identity_credit_transfer_transition::apply_identity_credit_transfer::ApplyIdentityCreditTransferTransition;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::identity::state_transition::identity_credit_transfer_transition::transition::IdentityCreditTransferTransitionWasm;
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name=applyIdentityCreditTransferTransition)]
+pub async fn apply_identity_credit_transfer_transition_wasm(
+    state_repository: ExternalStateRepositoryLike,
+    state_transition: &IdentityCreditTransferTransitionWasm,
+    execution_context: &StateTransitionExecutionContextWasm,
+) -> Result<(), JsValue> {
+    let wrapped_state_repository =
+        Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+    let instance = ApplyIdentityCreditTransferTransition::new(wrapped_state_repository);
+
+    instance
+        .apply(
+            &state_transition.to_owned().into(),
+            &execution_context.to_owned().into(),
+        )
+        .await
+        .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+    Ok(())
+}

package/src/identity/state_transition/identity_credit_transfer_transition/identity_credit_transfer_transition_basic_validator.rs

@@ -0,0 +1,66 @@
+use dpp::identity::state_transition::identity_credit_transfer_transition::validation::basic::identity_credit_transfer_basic::IdentityCreditTransferTransitionBasicValidator;
+
+use dpp::version::{ProtocolVersionValidator, COMPATIBILITY_MAP, LATEST_VERSION};
+use dpp::ProtocolError;
+
+use wasm_bindgen::prelude::*;
+
+use crate::errors::from_dpp_err;
+use crate::utils::ToSerdeJSONExt;
+use crate::validation::ValidationResultWasm;
+
+#[wasm_bindgen(js_name=IdentityCreditTransferTransitionBasicValidator)]
+pub struct IdentityCreditTransferTransitionBasicValidatorWasm(
+    IdentityCreditTransferTransitionBasicValidator,
+);
+
+impl From<IdentityCreditTransferTransitionBasicValidator>
+    for IdentityCreditTransferTransitionBasicValidatorWasm
+{
+    fn from(validator: IdentityCreditTransferTransitionBasicValidator) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityCreditTransferTransitionBasicValidator)]
+impl IdentityCreditTransferTransitionBasicValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Result<IdentityCreditTransferTransitionBasicValidatorWasm, JsValue> {
+        let protocol_version_validator = ProtocolVersionValidator::new(
+            LATEST_VERSION,
+            LATEST_VERSION,
+            COMPATIBILITY_MAP.clone(),
+        );
+
+        let validator =
+            IdentityCreditTransferTransitionBasicValidator::new(protocol_version_validator)
+                .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+        Ok(validator.into())
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        mut self,
+        raw_state_transition: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let current_protocol_version =
+            js_sys::Reflect::get(&raw_state_transition, &"protocolVersion".into())
+                .map(|v| v.as_f64().unwrap_or(LATEST_VERSION as f64) as u32)
+                .unwrap_or(LATEST_VERSION);
+
+        self.0
+            .protocol_version_validator()
+            .set_current_protocol_version(current_protocol_version);
+
+        let state_transition_object = raw_state_transition.with_serde_to_platform_value()?;
+
+        let validation_result = self
+            .0
+            .validate(&state_transition_object)
+            .await
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity/state_transition/identity_credit_transfer_transition/identity_credit_transfer_transition_state_validator.rs

@@ -0,0 +1,44 @@
+use crate::errors::from_dpp_err;
+use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
+use crate::validation::ValidationResultWasm;
+use crate::{IdentityCreditTransferTransitionWasm, StateTransitionExecutionContextWasm};
+use dpp::identity::state_transition::identity_credit_transfer_transition::validation::state::IdentityCreditTransferTransitionStateValidator;
+use dpp::identity::state_transition::identity_credit_transfer_transition::IdentityCreditTransferTransition;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=IdentityCreditTransferTransitionStateValidator)]
+pub struct IdentityCreditTransferTransitionStateValidatorWasm(
+    IdentityCreditTransferTransitionStateValidator<ExternalStateRepositoryLikeWrapper>,
+);
+
+#[wasm_bindgen(js_class=IdentityCreditTransferTransitionStateValidator)]
+impl IdentityCreditTransferTransitionStateValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> Result<IdentityCreditTransferTransitionStateValidatorWasm, JsValue> {
+        let state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+
+        let validator = IdentityCreditTransferTransitionStateValidator::new(state_repository);
+
+        Ok(Self(validator))
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        state_transition: &IdentityCreditTransferTransitionWasm,
+        execution_context: &StateTransitionExecutionContextWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let state_transition: IdentityCreditTransferTransition = state_transition.to_owned().into();
+
+        let validation_result = self
+            .0
+            .validate(&state_transition, &execution_context.to_owned().into())
+            .await
+            .map_err(from_dpp_err)?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity/state_transition/identity_credit_transfer_transition/mod.rs

@@ -0,0 +1,8 @@
+pub use transition::*;
+
+pub mod apply_identity_credit_transfer_transition;
+pub mod identity_credit_transfer_transition_basic_validator;
+pub mod identity_credit_transfer_transition_state_validator;
+pub mod transition;
+
+mod to_object;

package/src/identity/state_transition/identity_credit_transfer_transition/to_object.rs

@@ -0,0 +1,52 @@
+use dpp::identity::KeyID;
+use dpp::state_transition::StateTransitionIdentitySigned;
+use dpp::{
+    identifier::Identifier,
+    identity::state_transition::identity_credit_transfer_transition::IdentityCreditTransferTransition,
+    state_transition::StateTransitionLike,
+};
+use serde::Deserialize;
+use std::default::Default;
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct ToObjectOptions {
+    pub skip_signature: Option<bool>,
+}
+
+#[derive(Default)]
+pub struct ToObject {
+    pub transition_type: u8,
+    pub protocol_version: u32,
+    pub identity_id: Identifier,
+    pub recipient_id: Identifier,
+    pub amount: u64,
+    pub signature: Option<Vec<u8>>,
+    pub signature_public_key_id: Option<KeyID>,
+}
+
+pub fn to_object_struct(
+    transition: &IdentityCreditTransferTransition,
+    options: ToObjectOptions,
+) -> ToObject {
+    let mut to_object = ToObject {
+        transition_type: transition.get_type() as u8,
+        protocol_version: transition.get_protocol_version(),
+        identity_id: *transition.get_identity_id(),
+        recipient_id: *transition.get_recipient_id(),
+        amount: transition.get_amount(),
+        ..ToObject::default()
+    };
+
+    if !options.skip_signature.unwrap_or(false) {
+        let signature = Some(transition.get_signature().to_vec());
+        if let Some(signature) = &signature {
+            if !signature.is_empty() {
+                to_object.signature_public_key_id = transition.get_signature_public_key_id()
+            }
+        }
+        to_object.signature = signature;
+    }
+
+    to_object
+}