refactor(wallet): use an Option around fee_type for neater code

Author: aesedepece

wallet/src/actors/app/handlers/create_data_req.rs

@@ -10,7 +10,7 @@ use witnet_data_structures::{
 use crate::{
     actors::{app, worker},
     types::{
-        self, from_generic_type, into_generic_type, number_from_string, u32_to_string,
+        self, fee_compat, from_generic_type, into_generic_type, number_from_string, u32_to_string,
         DataRequestOutputHelper, FeeType, TransactionHelper,
     },
 };
@@ -26,8 +26,7 @@ pub struct CreateDataReqRequest {
     request: DataRequestOutput,
     #[serde(deserialize_with = "deserialize_fee_backwards_compatible")]
     fee: Fee,
-    #[serde(default)]
-    fee_type: FeeType,
+    fee_type: Option<FeeType>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -60,7 +59,7 @@ impl Handler<CreateDataReqRequest> for app::App {
 
         // For the sake of backwards compatibility, if the `fee_type` argument was provided, then we
         // treat the `fee` argument as such type, regardless of how it was originally deserialized.
-        let fee = msg.fee_type.fee_compat(msg.fee);
+        let fee = fee_compat(msg.fee, msg.fee_type);
 
         let f = fut::result(validated).and_then(move |request, slf: &mut Self, _ctx| {
             let params = types::DataReqParams { request, fee };

wallet/src/actors/app/handlers/create_vtt.rs

@@ -13,8 +13,9 @@ use witnet_data_structures::{
 use crate::{
     actors::{app, worker},
     types::{
-        self, from_generic_type, from_generic_type_vec, into_generic_type, into_generic_type_vec,
-        number_from_string, u32_to_string, FeeType, TransactionHelper, VttOutputParamsHelper,
+        self, fee_compat, from_generic_type, from_generic_type_vec, into_generic_type,
+        into_generic_type_vec, number_from_string, u32_to_string, FeeType, TransactionHelper,
+        VttOutputParamsHelper,
     },
 };
 
@@ -29,8 +30,7 @@ pub struct VttOutputParams {
 pub struct CreateVttRequest {
     #[serde(deserialize_with = "deserialize_fee_backwards_compatible")]
     fee: Fee,
-    #[serde(default)]
-    fee_type: FeeType,
+    fee_type: Option<FeeType>,
     label: Option<String>,
     #[serde(
         serialize_with = "into_generic_type_vec::<_, VttOutputParamsHelper, _>",
@@ -89,7 +89,7 @@ impl Handler<CreateVttRequest> for app::App {
 
         // For the sake of backwards compatibility, if the `fee_type` argument was provided, then we
         // treat the `fee` argument as such type, regardless of how it was originally deserialized.
-        let fee = msg.fee_type.fee_compat(msg.fee);
+        let fee = fee_compat(msg.fee, msg.fee_type);
 
         let f = fut::result(validated).and_then(move |outputs, act: &mut Self, _ctx| {
             let params = types::VttParams {

wallet/src/types.rs

@@ -277,27 +277,24 @@ pub struct SuperBlockNotification {
     pub consolidated_block_hashes: Vec<String>,
 }
 
-#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize)]
+#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub enum FeeType {
-    #[default]
     Absolute,
     Relative,
 }
 
-impl FeeType {
-    /// For the sake of backwards compatibility, turn a `Fee::Absolute` into `Fee::Relative` if the
-    /// `FeeType` is `Relative`, and a `Fee::Relative` into `Fee::Absolute` if the `FeeType` is
-    /// `Absolute`.
-    #[allow(clippy::cast_precision_loss)]
-    pub fn fee_compat(&self, fee: Fee) -> Fee {
-        match (self, fee) {
-            (&FeeType::Absolute, Fee::Relative(relative)) => Fee::from(relative.into_absolute(1)),
-            (&FeeType::Relative, Fee::Absolute(absolute)) => {
-                Fee::relative_from_float(absolute.as_nanowits() as f64)
-            }
-            _ => fee,
+/// For the sake of backwards compatibility, turn a `Fee::Absolute` into `Fee::Relative` if the
+/// `FeeType` is `Relative`, and a `Fee::Relative` into `Fee::Absolute` if the `FeeType` is
+/// `Absolute`.
+#[allow(clippy::cast_precision_loss)]
+pub fn fee_compat(fee: Fee, fee_type: Option<FeeType>) -> Fee {
+    match (fee, fee_type) {
+        (Fee::Relative(relative), Some(FeeType::Absolute)) => Fee::from(relative.into_absolute(1)),
+        (Fee::Absolute(absolute), Some(FeeType::Relative)) => {
+            Fee::relative_from_float(absolute.as_nanowits() as f64)
         }
+        _ => fee,
     }
 }
 
@@ -738,16 +735,22 @@ mod tests {
 
     #[test]
     fn test_fee_type_backwards_compatibility() {
-        let fee = FeeType::Absolute.fee_compat(Fee::absolute_from_nanowits(123456));
+        let fee = fee_compat(Fee::absolute_from_nanowits(123456), None);
+        assert_eq!(fee, Fee::absolute_from_nanowits(123456));
+
+        let fee = fee_compat(Fee::relative_from_float(123.456), None);
+        assert_eq!(fee, Fee::relative_from_float(123.456));
+
+        let fee = fee_compat(Fee::absolute_from_nanowits(123456), Some(FeeType::Absolute));
         assert_eq!(fee, Fee::absolute_from_nanowits(123456));
 
-        let fee = FeeType::Absolute.fee_compat(Fee::relative_from_float(123.456));
+        let fee = fee_compat(Fee::relative_from_float(123.456), Some(FeeType::Absolute));
         assert_eq!(fee, Fee::absolute_from_nanowits(123));
 
-        let fee = FeeType::Relative.fee_compat(Fee::absolute_from_nanowits(123456));
+        let fee = fee_compat(Fee::absolute_from_nanowits(123456), Some(FeeType::Relative));
         assert_eq!(fee, Fee::relative_from_float(123456.0));
 
-        let fee = FeeType::Relative.fee_compat(Fee::relative_from_float(123.456));
+        let fee = fee_compat(Fee::relative_from_float(123.456), Some(FeeType::Relative));
         assert_eq!(fee, Fee::relative_from_float(123.456));
     }
 }