feat(dpp): add fees API to rust wasm bindings

packages/rs-dpp/src/state_transition/fee/mod.rs

@@ -22,11 +22,11 @@ pub struct FeeResult {
     pub required_amount: Credits,
 }
 
-#[derive(Default)]
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct DummyFeesResult {
-    storage: Credits,
-    processing: Credits,
-    fee_refunds: Vec<Refunds>,
+    pub storage: Credits,
+    pub processing: Credits,
+    pub fee_refunds: Vec<Refunds>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]

packages/wasm-dpp/src/document/state_transition/document_batch_transition/mod.rs

@@ -1,4 +1,5 @@
 use dpp::identity::KeyID;
+use dpp::state_transition::fee::calculate_state_transition_fee_factory::calculate_state_transition_fee;
 use dpp::{
     document::{
         document_transition::document_base_transition,

packages/wasm-dpp/src/errors/consensus/fee/balance_is_not_enough_error.rs

@@ -1,27 +1,28 @@
+use dpp::state_transition::fee::Credits;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=BalanceIsNotEnoughError)]
 pub struct BalanceIsNotEnoughErrorWasm {
-    balance: u64,
-    fee: i64,
+    balance: Credits,
+    fee: Credits,
     code: u32,
 }
 
 impl BalanceIsNotEnoughErrorWasm {
-    pub fn new(balance: u64, fee: i64, code: u32) -> Self {
+    pub fn new(balance: Credits, fee: Credits, code: u32) -> Self {
         BalanceIsNotEnoughErrorWasm { balance, fee, code }
     }
 }
 
 #[wasm_bindgen(js_class=BalanceIsNotEnoughError)]
 impl BalanceIsNotEnoughErrorWasm {
     #[wasm_bindgen(js_name=getBalance)]
-    pub fn get_balance(&self) -> u64 {
+    pub fn get_balance(&self) -> Credits {
         self.balance
     }
 
     #[wasm_bindgen(js_name=getFee)]
-    pub fn get_fee(&self) -> i64 {
+    pub fn get_fee(&self) -> Credits {
         self.fee
     }
 

packages/wasm-dpp/src/errors/consensus_error.rs

@@ -185,8 +185,7 @@ pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue {
         }
         DPPConsensusError::FeeError(e) => match e {
             dpp::consensus::fee::FeeError::BalanceIsNotEnoughError { balance, fee } => {
-                // TODO decide about type for Fee
-                BalanceIsNotEnoughErrorWasm::new(*balance, *fee as i64, code).into()
+                BalanceIsNotEnoughErrorWasm::new(*balance, *fee, code).into()
             }
         },
         DPPConsensusError::SignatureError(e) => from_signature_error(e),

packages/wasm-dpp/src/state_transition/fee/calculate_operation_fees.rs

@@ -0,0 +1,24 @@
+use dpp::state_transition::fee::{
+    calculate_operation_fees::calculate_operation_fees, operations::Operation,
+};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    fee::dummy_fee_result::DummyFeesResultWasm,
+    utils::{Inner, IntoWasm},
+};
+
+use super::OperationWasm;
+
+#[wasm_bindgen(js_name=calculateOperationFees)]
+pub fn calculate_operation_fees_wasm(
+    operations: js_sys::Array,
+) -> Result<DummyFeesResultWasm, JsValue> {
+    let mut inner_operations: Vec<Operation> = vec![];
+    for operation in operations.iter() {
+        let operation = operation.to_wasm::<OperationWasm>("Operation")?.to_owned();
+        inner_operations.push(operation.into_inner())
+    }
+
+    Ok(calculate_operation_fees(&inner_operations).into())
+}

packages/wasm-dpp/src/state_transition/fee/calculate_state_transition_fee.rs

@@ -0,0 +1,15 @@
+use dpp::state_transition::fee::calculate_state_transition_fee_factory::calculate_state_transition_fee;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    conversion::create_state_transition_from_wasm_instance, fee::fee_result::FeeResultWasm,
+};
+
+#[wasm_bindgen(js_name=calculateStateTransitionFee)]
+pub fn calculate_state_transition_fee_wasm(
+    state_transition_js: &JsValue,
+) -> Result<FeeResultWasm, JsValue> {
+    let state_transition = create_state_transition_from_wasm_instance(state_transition_js)?;
+
+    Ok(calculate_state_transition_fee(&state_transition).into())
+}

packages/wasm-dpp/src/state_transition/fee/dummy_fee_result.rs

@@ -0,0 +1,83 @@
+use dpp::state_transition::fee::{DummyFeesResult, Refunds};
+use js_sys::{Array, BigInt};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    fee::refunds::RefundsWasm,
+    utils::{try_to_u64, Inner, IntoWasm, WithJsError},
+};
+
+#[wasm_bindgen(js_name=DummyFeesResult)]
+pub struct DummyFeesResultWasm(DummyFeesResult);
+
+#[wasm_bindgen(js_class=DummyFeesResult)]
+impl DummyFeesResultWasm {
+    #[wasm_bindgen(getter, js_name = "storageFee")]
+    pub fn storage_fee(&self) -> BigInt {
+        BigInt::from(self.0.storage)
+    }
+
+    #[wasm_bindgen(getter, js_name = "processingFee")]
+    pub fn processing_fee(&self) -> BigInt {
+        BigInt::from(self.0.processing)
+    }
+
+    #[wasm_bindgen(getter, js_name = "feeRefunds")]
+    pub fn fee_refunds(&self) -> js_sys::Array {
+        let js_refunds = js_sys::Array::new();
+        for refund in self.0.fee_refunds.iter().map(RefundsWasm::from) {
+            js_refunds.push(&refund.into());
+        }
+        js_refunds
+    }
+
+    #[wasm_bindgen(setter, js_name = "storageFee")]
+    pub fn set_storage_fee(&mut self, number: JsValue) -> Result<(), JsValue> {
+        let number = try_to_u64(number).with_js_error()?;
+        self.0.storage = number;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter, js_name = "processingFee")]
+    pub fn set_processing_fee(&mut self, number: JsValue) -> Result<(), JsValue> {
+        let number = try_to_u64(number).with_js_error()?;
+        self.0.processing = number;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter, js_name = "feeRefunds")]
+    pub fn set_fee_refunds(&mut self, js_fee_refunds: Array) -> Result<(), JsValue> {
+        let mut refunds = vec![];
+        for refund in js_fee_refunds.iter() {
+            let transition: Refunds = refund
+                .to_wasm::<RefundsWasm>("Refunds")?
+                .to_owned()
+                .into_inner();
+            refunds.push(transition);
+        }
+        self.0.fee_refunds = refunds;
+        Ok(())
+    }
+}
+
+impl From<DummyFeesResult> for DummyFeesResultWasm {
+    fn from(value: DummyFeesResult) -> Self {
+        DummyFeesResultWasm(value)
+    }
+}
+
+impl Inner for DummyFeesResultWasm {
+    type InnerItem = DummyFeesResult;
+
+    fn into_inner(self) -> Self::InnerItem {
+        self.0
+    }
+
+    fn inner(&self) -> &Self::InnerItem {
+        &self.0
+    }
+
+    fn inner_mut(&mut self) -> &mut Self::InnerItem {
+        &mut self.0
+    }
+}

packages/wasm-dpp/src/state_transition/fee/fee_result.rs

@@ -0,0 +1,125 @@
+use dpp::state_transition::fee::{FeeResult, Refunds};
+use js_sys::BigInt;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    fee::refunds::RefundsWasm,
+    utils::{try_to_u64, Inner, IntoWasm, WithJsError},
+};
+
+#[wasm_bindgen(js_name=FeeResult)]
+pub struct FeeResultWasm(FeeResult);
+
+#[wasm_bindgen(js_class=FeeResult)]
+impl FeeResultWasm {
+    #[allow(clippy::new_without_default)]
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> FeeResultWasm {
+        FeeResultWasm(FeeResult::default())
+    }
+
+    #[wasm_bindgen(getter, js_name = "storageFee")]
+    pub fn storage_fee(&self) -> BigInt {
+        BigInt::from(self.0.storage_fee)
+    }
+
+    #[wasm_bindgen(getter, js_name = "processingFee")]
+    pub fn processing_fee(&self) -> BigInt {
+        BigInt::from(self.0.processing_fee)
+    }
+
+    #[wasm_bindgen(getter, js_name = "feeRefunds")]
+    pub fn fee_refunds(&self) -> js_sys::Array {
+        let js_refunds = js_sys::Array::new();
+        for refund in self.0.fee_refunds.iter().map(RefundsWasm::from) {
+            js_refunds.push(&refund.into());
+        }
+        js_refunds
+    }
+
+    #[wasm_bindgen(getter, js_name = "totalRefunds")]
+    pub fn total_refunds(&self) -> BigInt {
+        BigInt::from(self.0.total_refunds)
+    }
+
+    #[wasm_bindgen(getter, js_name = "desiredAmount")]
+    pub fn desired_amount(&self) -> BigInt {
+        BigInt::from(self.0.desired_amount)
+    }
+
+    #[wasm_bindgen(getter, js_name = "requiredAmount")]
+    pub fn required_amount(&self) -> BigInt {
+        BigInt::from(self.0.required_amount)
+    }
+
+    #[wasm_bindgen(setter, js_name = "storageFee")]
+    pub fn set_storage_fee(&mut self, number: JsValue) -> Result<(), JsValue> {
+        let number = try_to_u64(number).with_js_error()?;
+        self.0.storage_fee = number;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter, js_name = "processingFee")]
+    pub fn set_processing_fee(&mut self, number: JsValue) -> Result<(), JsValue> {
+        let number = try_to_u64(number).with_js_error()?;
+        self.0.processing_fee = number;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter, js_name = "feeRefunds")]
+    pub fn set_fee_refunds(&mut self, js_fee_refunds: js_sys::Array) -> Result<(), JsValue> {
+        let mut refunds = vec![];
+        for refund in js_fee_refunds.iter() {
+            let transition: Refunds = refund
+                .to_wasm::<RefundsWasm>("Refunds")?
+                .to_owned()
+                .into_inner();
+            refunds.push(transition);
+        }
+        self.0.fee_refunds = refunds;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter, js_name = "desiredAmount")]
+    pub fn set_desired_amount(&mut self, number: JsValue) -> Result<(), JsValue> {
+        let number = try_to_u64(number).with_js_error()?;
+        self.0.desired_amount = number;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter, js_name = "requiredAmount")]
+    pub fn set_required_amount(&mut self, number: JsValue) -> Result<(), JsValue> {
+        let number = try_to_u64(number).with_js_error()?;
+        self.0.required_amount = number;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter, js_name = "totalRefunds")]
+    pub fn set_total_refunds(&mut self, number: JsValue) -> Result<(), JsValue> {
+        let number = try_to_u64(number).with_js_error()?;
+        self.0.total_refunds = number;
+        Ok(())
+    }
+}
+
+impl From<FeeResult> for FeeResultWasm {
+    fn from(value: FeeResult) -> Self {
+        FeeResultWasm(value)
+    }
+}
+
+impl Inner for FeeResultWasm {
+    type InnerItem = FeeResult;
+
+    fn into_inner(self) -> Self::InnerItem {
+        self.0
+    }
+
+    fn inner(&self) -> &Self::InnerItem {
+        &self.0
+    }
+
+    fn inner_mut(&mut self) -> &mut Self::InnerItem {
+        &mut self.0
+    }
+}

packages/wasm-dpp/src/state_transition/fee/mod.rs

@@ -0,0 +1,36 @@
+use dpp::state_transition::fee::operations::Operation;
+use wasm_bindgen::prelude::*;
+
+use crate::utils::Inner;
+mod calculate_operation_fees;
+mod calculate_state_transition_fee;
+mod dummy_fee_result;
+mod fee_result;
+mod operations;
+mod refunds;
+
+#[wasm_bindgen(js_name=Operation)]
+#[derive(Clone)]
+pub struct OperationWasm(Operation);
+
+impl From<Operation> for OperationWasm {
+    fn from(value: Operation) -> Self {
+        OperationWasm(value)
+    }
+}
+
+impl Inner for OperationWasm {
+    type InnerItem = Operation;
+
+    fn into_inner(self) -> Self::InnerItem {
+        self.0
+    }
+
+    fn inner(&self) -> &Self::InnerItem {
+        &self.0
+    }
+
+    fn inner_mut(&mut self) -> &mut Self::InnerItem {
+        &mut self.0
+    }
+}

packages/wasm-dpp/src/state_transition/fee/operations/mod.rs

@@ -0,0 +1,7 @@
+mod pre_calculated_operation;
+mod read_operation;
+mod signature_verification_operation;
+
+pub use pre_calculated_operation::*;
+pub use read_operation::*;
+pub use signature_verification_operation::*;