pshenmic-dpp 1.0.4 → 1.0.6

package/packages/identity_transitions/src/create_transition/mod.rs

@@ -1,18 +1,22 @@
-mod public_key_in_creation;
-
-use dpp::platform_value::string_encoding::Encoding::Base58;
-use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use crate::public_key_in_creation::IdentityPublicKeyInCreationWASM;
+use dpp::identity::state_transition::AssetLockProved;
+use dpp::platform_value::BinaryData;
+use dpp::prelude::UserFeeIncrease;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable};
 use dpp::state_transition::identity_create_transition::IdentityCreateTransition;
 use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0;
+use dpp::state_transition::identity_create_transition::v0::IdentityCreateTransitionV0;
+use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
 use dpp::state_transition::{StateTransition, StateTransitionLike};
-use dpp::version::PlatformVersion;
+use pshenmic_dpp_asset_lock_proof::AssetLockProofWASM;
+use pshenmic_dpp_enums::platform::PlatformVersionWASM;
+use pshenmic_dpp_identifier::IdentifierWASM;
 use pshenmic_dpp_state_transition::StateTransitionWASM;
 use pshenmic_dpp_utils::WithJsError;
-use public_key_in_creation::IdentityPublicKeyInCreationWASM;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
-#[wasm_bindgen(js_name = IdentityCreateTransitionWASM)]
+#[wasm_bindgen(js_name = "IdentityCreateTransitionWASM")]
 #[derive(Clone)]
 pub struct IdentityCreateTransitionWASM(IdentityCreateTransition);
 
@@ -31,16 +35,51 @@ impl From<IdentityCreateTransitionWASM> for IdentityCreateTransition {
 #[wasm_bindgen]
 impl IdentityCreateTransitionWASM {
     #[wasm_bindgen(constructor)]
-    pub fn new(platform_version: u32) -> Result<IdentityCreateTransitionWASM, JsValue> {
-        let platform_version =
-            &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
+    pub fn new(
+        js_public_keys: &js_sys::Array,
+        asset_lock: &AssetLockProofWASM,
+        user_fee_increase: UserFeeIncrease,
+        signature: Option<Vec<u8>>,
+        js_identity_id: &JsValue,
+    ) -> Result<IdentityCreateTransitionWASM, JsValue> {
+        let public_keys: Vec<IdentityPublicKeyInCreationWASM> =
+            IdentityPublicKeyInCreationWASM::vec_from_js_value(js_public_keys)?;
+        let identity_id = IdentifierWASM::try_from(js_identity_id)?;
+
+        Ok(IdentityCreateTransitionWASM(IdentityCreateTransition::V0(
+            IdentityCreateTransitionV0 {
+                public_keys: public_keys.iter().map(|key| key.clone().into()).collect(),
+                asset_lock_proof: asset_lock.clone().into(),
+                user_fee_increase,
+                signature: BinaryData::from(signature.unwrap_or(vec![])),
+                identity_id: identity_id.into(),
+            },
+        )))
+    }
 
-        IdentityCreateTransition::default_versioned(platform_version)
+    #[wasm_bindgen(js_name = "default")]
+    pub fn default(js_platform_version: JsValue) -> Result<IdentityCreateTransitionWASM, JsValue> {
+        let platform_version = PlatformVersionWASM::try_from(js_platform_version)?;
+
+        IdentityCreateTransition::default_versioned(&platform_version.into())
             .map(Into::into)
             .map_err(|err| JsValue::from_str(&*err.to_string()))
     }
 
-    #[wasm_bindgen(js_name = "defaultVersioned")]
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityCreateTransitionWASM, JsValue> {
+        let rs_transition =
+            IdentityCreateTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error()?;
+
+        Ok(IdentityCreateTransitionWASM(rs_transition))
+    }
+
+    #[wasm_bindgen(getter = "publicKeys")]
     pub fn get_public_keys(&self) -> Vec<IdentityPublicKeyInCreationWASM> {
         self.0
             .public_keys()
@@ -50,28 +89,63 @@ impl IdentityCreateTransitionWASM {
     }
 
     #[wasm_bindgen(js_name = "getIdentifier")]
-    pub fn get_identity_id(&self) -> String {
-        self.0.identity_id().to_string(Base58)
+    pub fn get_identity_id(&self) -> IdentifierWASM {
+        self.0.identity_id().into()
     }
 
-    #[wasm_bindgen(js_name = "getUserFeeIncrease")]
+    #[wasm_bindgen(getter = "userFeeIncrease")]
     pub fn get_user_fee_increase(&self) -> u16 {
         self.0.user_fee_increase()
     }
 
-    #[wasm_bindgen(js_name = "toStateTransition")]
-    pub fn to_state_transition(&self) -> StateTransitionWASM {
-        StateTransitionWASM::from(StateTransition::IdentityCreate(self.clone().0))
+    #[wasm_bindgen(js_name = "getSignature")]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
     }
 
-    #[wasm_bindgen(js_name = "toBytes")]
-    pub fn to_bytes(&self) -> Result<JsValue, JsValue> {
-        let bytes = self.0.serialize_to_bytes().with_js_error();
+    #[wasm_bindgen(js_name = "getSignableBytes")]
+    pub fn get_signable_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.signable_bytes().with_js_error()
+    }
 
-        match bytes {
-            Ok(bytes) => Ok(JsValue::from(bytes.clone())),
-            Err(err) => Err(err),
-        }
+    #[wasm_bindgen(getter = "assetLock")]
+    pub fn get_asset_lock_proof(&self) -> AssetLockProofWASM {
+        AssetLockProofWASM::from(self.0.asset_lock_proof().clone())
+    }
+
+    #[wasm_bindgen(setter = "publicKeys")]
+    pub fn set_public_keys(&mut self, js_public_keys: &js_sys::Array) -> Result<(), JsValue> {
+        let public_keys: Vec<IdentityPublicKeyInCreationWASM> =
+            IdentityPublicKeyInCreationWASM::vec_from_js_value(js_public_keys)?;
+
+        self.0.set_public_keys(
+            public_keys
+                .iter()
+                .map(|key| IdentityPublicKeyInCreation::from(key.clone()))
+                .collect(),
+        );
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = "userFeeIncrease")]
+    pub fn set_user_fee_increase(&mut self, amount: u16) {
+        self.0.set_user_fee_increase(amount)
+    }
+
+    #[wasm_bindgen(js_name = "setSignature")]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature_bytes(signature)
+    }
+
+    #[wasm_bindgen(setter = "assetLock")]
+    pub fn set_asset_lock_proof(&mut self, proof: AssetLockProofWASM) -> Result<(), JsValue> {
+        self.0.set_asset_lock_proof(proof.into()).with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        StateTransitionWASM::from(StateTransition::IdentityCreate(self.clone().0))
     }
 
     #[wasm_bindgen(js_name = "fromStateTransition")]
@@ -82,18 +156,9 @@ impl IdentityCreateTransitionWASM {
 
         match rs_st {
             StateTransition::IdentityCreate(st) => Ok(IdentityCreateTransitionWASM(st)),
-            _ => Err(JsValue::from_str(&"Invalid state transition type)")),
-        }
-    }
-
-    #[wasm_bindgen(js_name = "fromBytes")]
-    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityCreateTransitionWASM, JsValue> {
-        let rs_transition =
-            IdentityCreateTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error();
-
-        match rs_transition {
-            Ok(rs_st) => Ok(IdentityCreateTransitionWASM(rs_st)),
-            Err(err) => Err(err),
+            _ => Err(JsValue::from_str(
+                &"Invalid state document_transition type)",
+            )),
         }
     }
 }

package/packages/identity_transitions/src/credit_withdrawal_transition/mod.rs

@@ -0,0 +1,212 @@
+use dpp::identity::KeyID;
+use dpp::identity::state_transition::OptionallyAssetLockProved;
+use dpp::platform_value::Identifier;
+use dpp::prelude::{IdentityNonce, UserFeeIncrease};
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable};
+use dpp::state_transition::identity_credit_withdrawal_transition::IdentityCreditWithdrawalTransition;
+use dpp::state_transition::identity_credit_withdrawal_transition::accessors::IdentityCreditWithdrawalTransitionAccessorsV0;
+use dpp::state_transition::identity_credit_withdrawal_transition::v0::IdentityCreditWithdrawalTransitionV0;
+use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned, StateTransitionLike};
+use pshenmic_dpp_asset_lock_proof::AssetLockProofWASM;
+use pshenmic_dpp_core_script::CoreScriptWASM;
+use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
+use pshenmic_dpp_enums::withdrawal::PoolingWASM;
+use pshenmic_dpp_identifier::IdentifierWASM;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::{IntoWasm, WithJsError};
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "IdentityCreditWithdrawalTransitionWASM")]
+pub struct IdentityCreditWithdrawalTransitionWASM(IdentityCreditWithdrawalTransition);
+
+#[wasm_bindgen]
+impl IdentityCreditWithdrawalTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        js_identity_id: JsValue,
+        amount: u64,
+        core_fee_per_byte: u32,
+        js_pooling: JsValue,
+        output_script: &CoreScriptWASM,
+        nonce: Option<IdentityNonce>,
+        user_fee_increase: Option<UserFeeIncrease>,
+    ) -> Result<IdentityCreditWithdrawalTransitionWASM, JsValue> {
+        let pooling = PoolingWASM::try_from(js_pooling)?;
+        let identity_id: Identifier = IdentifierWASM::try_from(js_identity_id)?.into();
+
+        Ok(IdentityCreditWithdrawalTransitionWASM(
+            IdentityCreditWithdrawalTransition::V0(IdentityCreditWithdrawalTransitionV0 {
+                identity_id,
+                amount,
+                core_fee_per_byte,
+                pooling: pooling.into(),
+                output_script: output_script.clone().into(),
+                nonce: nonce.unwrap_or(0),
+                user_fee_increase: user_fee_increase.unwrap_or(0),
+                signature_public_key_id: 0,
+                signature: Default::default(),
+            }),
+        ))
+    }
+
+    #[wasm_bindgen(getter = "outputScript")]
+    pub fn get_output_script(&self) -> Option<CoreScriptWASM> {
+        match self.0.output_script() {
+            None => None,
+            Some(script) => Some(script.into()),
+        }
+    }
+
+    #[wasm_bindgen(getter = "pooling")]
+    pub fn get_pooling(&self) -> String {
+        PoolingWASM::from(self.0.pooling()).into()
+    }
+
+    #[wasm_bindgen(getter = "identityId")]
+    pub fn get_identity_id(&self) -> IdentifierWASM {
+        IdentifierWASM::from(self.0.identity_id())
+    }
+
+    #[wasm_bindgen(getter = "userFeeIncrease")]
+    pub fn get_user_fee_increase(&self) -> UserFeeIncrease {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(getter = "nonce")]
+    pub fn get_nonce(&self) -> IdentityNonce {
+        self.0.nonce()
+    }
+
+    #[wasm_bindgen(getter = "amount")]
+    pub fn get_amount(&self) -> u64 {
+        self.0.amount()
+    }
+
+    #[wasm_bindgen(js_name = "getPurposeRequirement")]
+    pub fn get_purpose_requirement(&self) -> Vec<String> {
+        self.0
+            .purpose_requirement()
+            .iter()
+            .map(|purpose| PurposeWASM::from(purpose.clone()).into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = "getModifiedDataIds")]
+    pub fn get_modified_data_ids(&self) -> Vec<IdentifierWASM> {
+        self.0
+            .modified_data_ids()
+            .iter()
+            .map(|id| id.clone().into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = "getOptionalAssetLockProof")]
+    pub fn get_optional_asset_lock_proof(&self) -> JsValue {
+        match self.0.optional_asset_lock_proof() {
+            Some(asset_lock) => JsValue::from(AssetLockProofWASM::from(asset_lock.clone())),
+            None => JsValue::null(),
+        }
+    }
+
+    #[wasm_bindgen(setter = "outputScript")]
+    pub fn set_output_script(&mut self, js_script: &JsValue) -> Result<(), JsValue> {
+        match js_script.is_undefined() {
+            true => self.0.set_output_script(None),
+            false => {
+                let script: CoreScriptWASM = js_script
+                    .to_wasm::<CoreScriptWASM>("CoreScriptWASM")?
+                    .clone();
+                self.0.set_output_script(Some(script.clone().into()))
+            }
+        };
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = "pooling")]
+    pub fn set_pooling(&mut self, js_pooling: JsValue) -> Result<(), JsValue> {
+        let pooling: PoolingWASM = PoolingWASM::try_from(js_pooling)?;
+        Ok(self.0.set_pooling(pooling.into()))
+    }
+
+    #[wasm_bindgen(setter = "identityId")]
+    pub fn set_identity_id(&mut self, js_identity_id: JsValue) -> Result<(), JsValue> {
+        let identity_id = IdentifierWASM::try_from(js_identity_id)?;
+
+        Ok(self.0.set_identity_id(identity_id.into()))
+    }
+
+    #[wasm_bindgen(setter = "userFeeIncrease")]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: UserFeeIncrease) {
+        self.0.set_user_fee_increase(user_fee_increase);
+    }
+
+    #[wasm_bindgen(setter = "nonce")]
+    pub fn set_nonce(&mut self, nonce: IdentityNonce) {
+        self.0.set_nonce(nonce)
+    }
+
+    #[wasm_bindgen(setter = "amount")]
+    pub fn set_amount(&mut self, amount: u64) {
+        self.0.set_amount(amount)
+    }
+
+    #[wasm_bindgen(getter = "signature")]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
+    }
+
+    #[wasm_bindgen(js_name = "getSignableBytes")]
+    pub fn get_signable_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.signable_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(getter = "signaturePublicKeyId")]
+    pub fn get_signature_public_key_id(&self) -> KeyID {
+        self.0.signature_public_key_id()
+    }
+
+    #[wasm_bindgen(setter = "signature")]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature_bytes(signature)
+    }
+
+    #[wasm_bindgen(setter = "signaturePublicKeyId")]
+    pub fn set_signature_public_key_id(&mut self, signature_public_key_id: KeyID) {
+        self.0.set_signature_public_key_id(signature_public_key_id)
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityCreditWithdrawalTransitionWASM, JsValue> {
+        let rs_transition =
+            IdentityCreditWithdrawalTransition::deserialize_from_bytes(bytes.as_slice())
+                .with_js_error()?;
+
+        Ok(IdentityCreditWithdrawalTransitionWASM(rs_transition))
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        StateTransitionWASM::from(StateTransition::from(self.0.clone()))
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        st: StateTransitionWASM,
+    ) -> Result<IdentityCreditWithdrawalTransitionWASM, JsValue> {
+        let rs_st: StateTransition = st.into();
+
+        match rs_st {
+            StateTransition::IdentityCreditWithdrawal(st) => {
+                Ok(IdentityCreditWithdrawalTransitionWASM(st))
+            }
+            _ => Err(JsValue::from_str(&"Invalid state transition type)")),
+        }
+    }
+}

package/packages/identity_transitions/src/identity_credit_transfer_transition/mod.rs

@@ -0,0 +1,169 @@
+use dpp::platform_value::BinaryData;
+use dpp::prelude::Identifier;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable};
+use dpp::state_transition::identity_credit_transfer_transition::IdentityCreditTransferTransition;
+use dpp::state_transition::identity_credit_transfer_transition::accessors::IdentityCreditTransferTransitionAccessorsV0;
+use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned, StateTransitionLike};
+use pshenmic_dpp_enums::platform::PlatformVersionWASM;
+use pshenmic_dpp_identifier::IdentifierWASM;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::WithJsError;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = IdentityCreditTransferWASM)]
+#[derive(Clone)]
+pub struct IdentityCreditTransferWASM(IdentityCreditTransferTransition);
+
+#[wasm_bindgen]
+impl IdentityCreditTransferWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        amount: u64,
+        js_sender: &JsValue,
+        js_recipient: &JsValue,
+        nonce: u64,
+        js_platform_version_wasm: &JsValue,
+    ) -> Result<IdentityCreditTransferWASM, JsValue> {
+        let platform_version_wasm = match js_platform_version_wasm.is_undefined() {
+            true => PlatformVersionWASM::PLATFORM_V1,
+            false => PlatformVersionWASM::try_from(js_platform_version_wasm.clone())?,
+        };
+
+        let rs_transfer_transition_creation =
+            IdentityCreditTransferTransition::default_versioned(&platform_version_wasm.into())
+                .with_js_error();
+
+        let mut rs_transition = match rs_transfer_transition_creation {
+            Ok(rs_transition) => rs_transition,
+            Err(err) => wasm_bindgen::throw_val(err),
+        };
+
+        let sender: Identifier = IdentifierWASM::try_from(js_sender)?.into();
+
+        let recipient: Identifier = IdentifierWASM::try_from(js_recipient)?.into();
+
+        rs_transition.set_recipient_id(recipient);
+        rs_transition.set_identity_id(sender);
+        rs_transition.set_amount(amount);
+        rs_transition.set_nonce(nonce);
+
+        Ok(IdentityCreditTransferWASM(rs_transition))
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityCreditTransferWASM, JsValue> {
+        let rs_transition =
+            IdentityCreditTransferTransition::deserialize_from_bytes(bytes.as_slice())
+                .with_js_error()?;
+
+        Ok(IdentityCreditTransferWASM(rs_transition))
+    }
+
+    #[wasm_bindgen(setter = "recipientId")]
+    pub fn set_recipient_id(&mut self, js_recipient: &JsValue) -> Result<(), JsValue> {
+        let recipient: Identifier = IdentifierWASM::try_from(js_recipient)?.into();
+
+        Ok(self.0.set_recipient_id(recipient))
+    }
+
+    #[wasm_bindgen(setter = "senderId")]
+    pub fn set_sender_id(&mut self, js_sender: &JsValue) -> Result<(), JsValue> {
+        let sender: Identifier = IdentifierWASM::try_from(js_sender)?.into();
+
+        Ok(self.0.set_identity_id(sender))
+    }
+
+    #[wasm_bindgen(setter = "amount")]
+    pub fn set_amount(&mut self, amount: u64) {
+        self.0.set_amount(amount)
+    }
+
+    #[wasm_bindgen(setter = "nonce")]
+    pub fn set_nonce(&mut self, nonce: u64) {
+        self.0.set_nonce(nonce)
+    }
+
+    #[wasm_bindgen(setter = "signature")]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature_bytes(signature)
+    }
+
+    #[wasm_bindgen(setter = "signaturePublicKeyId")]
+    pub fn set_signature_public_key_id(&mut self, public_key_id: u32) {
+        self.0.set_signature_public_key_id(public_key_id)
+    }
+
+    #[wasm_bindgen(setter = "userFeeIncrease")]
+    pub fn set_user_fee_increase(&mut self, amount: u16) {
+        self.0.set_user_fee_increase(amount)
+    }
+
+    #[wasm_bindgen(getter = "signature")]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
+    }
+
+    #[wasm_bindgen(js_name = "getSignableBytes")]
+    pub fn get_signable_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.signable_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(getter = "signaturePublicKeyId")]
+    pub fn get_signature_public_key_id(&self) -> u32 {
+        self.0.signature_public_key_id()
+    }
+
+    #[wasm_bindgen(getter = "userFeeIncrease")]
+    pub fn get_user_fee_increase(&self) -> u16 {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(getter = "recipientId")]
+    pub fn get_recipient_id(&self) -> IdentifierWASM {
+        self.0.recipient_id().into()
+    }
+
+    #[wasm_bindgen(getter = "senderId")]
+    pub fn get_identity_id(&self) -> IdentifierWASM {
+        self.0.identity_id().into()
+    }
+
+    #[wasm_bindgen(getter = "amount")]
+    pub fn get_amount(&self) -> u64 {
+        self.0.amount()
+    }
+
+    #[wasm_bindgen(getter = "nonce")]
+    pub fn get_nonce(&self) -> u64 {
+        self.0.nonce()
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        StateTransitionWASM::from(StateTransition::from(self.0.clone()))
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        st: StateTransitionWASM,
+    ) -> Result<IdentityCreditTransferWASM, JsValue> {
+        let rs_st: StateTransition = st.into();
+
+        match rs_st {
+            StateTransition::IdentityCreditTransfer(st) => Ok(IdentityCreditTransferWASM(st)),
+            _ => Err(JsValue::from_str(&"Invalid state transition type)")),
+        }
+    }
+}
+
+impl IdentityCreditTransferWASM {
+    pub fn set_signature_binary_data(&mut self, data: BinaryData) {
+        self.0.set_signature(data)
+    }
+}

package/packages/identity_transitions/src/lib.rs

@@ -1 +1,6 @@
-mod create_transition;
+pub mod create_transition;
+pub mod credit_withdrawal_transition;
+pub mod identity_credit_transfer_transition;
+pub mod public_key_in_creation;
+pub mod top_up_transition;
+pub mod update_transition;