pshenmic-dpp 1.0.5 → 1.0.6

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;

package/packages/identity_transitions/src/{create_transition/public_key_in_creation → public_key_in_creation}/mod.rs

@@ -11,9 +11,11 @@ use pshenmic_dpp_enums::keys::key_type::KeyTypeWASM;
 use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
 use pshenmic_dpp_enums::keys::security_level::SecurityLevelWASM;
 use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
+use pshenmic_dpp_utils::IntoWasm;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
+#[derive(Clone)]
 #[wasm_bindgen(js_name = "IdentityPublicKeyInCreationWASM")]
 pub struct IdentityPublicKeyInCreationWASM(IdentityPublicKeyInCreation);
 
@@ -29,6 +31,16 @@ impl From<IdentityPublicKeyInCreationWASM> for IdentityPublicKeyInCreation {
     }
 }
 
+impl TryFrom<JsValue> for IdentityPublicKeyInCreationWASM {
+    type Error = JsValue;
+    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        let value =
+            value.to_wasm::<IdentityPublicKeyInCreationWASM>("IdentityPublicKeyInCreationWASM")?;
+
+        Ok(value.clone())
+    }
+}
+
 impl From<IdentityPublicKeyInCreationWASM> for IdentityPublicKey {
     fn from(value: IdentityPublicKeyInCreationWASM) -> Self {
         let contract_bounds = match value.0.contract_bounds() {
@@ -54,15 +66,19 @@ impl IdentityPublicKeyInCreationWASM {
     #[wasm_bindgen(constructor)]
     pub fn new(
         id: u32,
-        purpose: PurposeWASM,
-        security_level: SecurityLevelWASM,
-        key_type: KeyTypeWASM,
+        js_purpose: JsValue,
+        js_security_level: JsValue,
+        js_key_type: JsValue,
         read_only: bool,
         binary_data: Vec<u8>,
         signature: Vec<u8>,
-    ) -> IdentityPublicKeyInCreationWASM {
-        IdentityPublicKeyInCreationWASM(IdentityPublicKeyInCreation::V0(
-            IdentityPublicKeyInCreationV0 {
+    ) -> Result<IdentityPublicKeyInCreationWASM, JsValue> {
+        let purpose = PurposeWASM::try_from(js_purpose)?;
+        let security_level = SecurityLevelWASM::try_from(js_security_level)?;
+        let key_type = KeyTypeWASM::try_from(js_key_type)?;
+
+        Ok(IdentityPublicKeyInCreationWASM(
+            IdentityPublicKeyInCreation::V0(IdentityPublicKeyInCreationV0 {
                 id,
                 key_type: KeyType::from(key_type),
                 purpose: Purpose::from(purpose),
@@ -71,7 +87,7 @@ impl IdentityPublicKeyInCreationWASM {
                 read_only,
                 data: BinaryData::from(binary_data),
                 signature: BinaryData::from(signature),
-            },
+            }),
         ))
     }
 
@@ -88,48 +104,53 @@ impl IdentityPublicKeyInCreationWASM {
         )
     }
 
-    #[wasm_bindgen(js_name = getKeyId)]
+    #[wasm_bindgen(getter = keyId)]
     pub fn get_key_id(&self) -> u32 {
         self.0.id()
     }
 
-    #[wasm_bindgen(js_name = getPurpose)]
+    #[wasm_bindgen(getter = purpose)]
     pub fn get_purpose(&self) -> String {
         PurposeWASM::from(self.0.purpose()).into()
     }
 
-    #[wasm_bindgen(js_name = getSecurityLevel)]
+    #[wasm_bindgen(getter = securityLevel)]
     pub fn get_security_level(&self) -> String {
         SecurityLevelWASM::from(self.0.security_level()).into()
     }
 
-    #[wasm_bindgen(js_name = getKeyType)]
+    #[wasm_bindgen(getter = keyType)]
     pub fn get_key_type(&self) -> String {
         KeyTypeWASM::from(self.0.key_type()).into()
     }
 
-    #[wasm_bindgen(js_name = getReadOnly)]
+    #[wasm_bindgen(getter = readOnly)]
     pub fn get_read_only(&self) -> bool {
         self.0.read_only()
     }
 
-    #[wasm_bindgen(js_name = getData)]
-    pub fn get_data(&self) -> String {
-        self.0.data().to_string(Hex)
+    #[wasm_bindgen(getter = data)]
+    pub fn get_data(&self) -> Vec<u8> {
+        self.0.data().to_vec()
+    }
+
+    #[wasm_bindgen(getter = signature)]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
     }
 
-    #[wasm_bindgen(js_name = setKeyId)]
+    #[wasm_bindgen(setter = keyId)]
     pub fn set_key_id(&mut self, key_id: u32) {
         self.0.set_id(key_id)
     }
 
-    #[wasm_bindgen(js_name = setPurpose)]
+    #[wasm_bindgen(setter = purpose)]
     pub fn set_purpose(&mut self, js_purpose: JsValue) -> Result<(), JsValue> {
         let purpose = PurposeWASM::try_from(js_purpose)?;
         Ok(self.0.set_purpose(Purpose::from(purpose)))
     }
 
-    #[wasm_bindgen(js_name = setSecurityLevel)]
+    #[wasm_bindgen(setter = securityLevel)]
     pub fn set_security_level(&mut self, js_security_level: JsValue) -> Result<(), JsValue> {
         let security_level = SecurityLevelWASM::try_from(js_security_level)?;
         Ok(self
@@ -137,14 +158,40 @@ impl IdentityPublicKeyInCreationWASM {
             .set_security_level(SecurityLevel::from(security_level)))
     }
 
-    #[wasm_bindgen(js_name = setReadOnly)]
+    #[wasm_bindgen(setter = keyType)]
+    pub fn set_key_type(&mut self, key_type: JsValue) -> Result<(), JsValue> {
+        let key_type = KeyTypeWASM::try_from(key_type)?;
+        self.0.set_type(key_type.into());
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = readOnly)]
     pub fn set_read_only(&mut self, read_only: bool) {
         self.0.set_read_only(read_only)
     }
 
-    #[wasm_bindgen(js_name = setData)]
+    #[wasm_bindgen(setter = data)]
     pub fn set_data(&mut self, binary_data: Vec<u8>) {
         let data = BinaryData::from(binary_data);
         self.0.set_data(data)
     }
+
+    #[wasm_bindgen(setter = signature)]
+    pub fn set_signature(&mut self, binary_data: Vec<u8>) {
+        let signature = BinaryData::from(binary_data);
+        self.0.set_signature(signature)
+    }
+}
+
+impl IdentityPublicKeyInCreationWASM {
+    pub fn vec_from_js_value(
+        js_add_public_keys: &js_sys::Array,
+    ) -> Result<Vec<IdentityPublicKeyInCreationWASM>, JsValue> {
+        let add_public_keys: Vec<IdentityPublicKeyInCreationWASM> = js_add_public_keys
+            .iter()
+            .map(|key| IdentityPublicKeyInCreationWASM::try_from(key))
+            .collect::<Result<Vec<IdentityPublicKeyInCreationWASM>, JsValue>>()?;
+
+        Ok(add_public_keys)
+    }
 }