feat(wallet): enable backwards compatibility with fee_type argument

Author: aesedepece

data_structures/src/fee.rs

@@ -145,6 +145,18 @@ impl fmt::Display for Fee {
     }
 }
 
+impl From<AbsoluteFee> for Fee {
+    fn from(absolute: AbsoluteFee) -> Self {
+        Self::Absolute(absolute)
+    }
+}
+
+impl From<RelativeFee> for Fee {
+    fn from(relative: RelativeFee) -> Self {
+        Self::Relative(relative)
+    }
+}
+
 /// Allow backwards compatibility with old Wallet API clients that may provide fee values without
 /// tagging whether they are absolute or relative.
 ///

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

@@ -11,7 +11,7 @@ use crate::{
     actors::{app, worker},
     types::{
         self, from_generic_type, into_generic_type, number_from_string, u32_to_string,
-        DataRequestOutputHelper, TransactionHelper,
+        DataRequestOutputHelper, FeeType, TransactionHelper,
     },
 };
 
@@ -26,6 +26,8 @@ pub struct CreateDataReqRequest {
     request: DataRequestOutput,
     #[serde(deserialize_with = "deserialize_fee_backwards_compatible")]
     fee: Fee,
+    #[serde(default)]
+    fee_type: FeeType,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -56,11 +58,12 @@ impl Handler<CreateDataReqRequest> for app::App {
     fn handle(&mut self, msg: CreateDataReqRequest, _ctx: &mut Self::Context) -> Self::Result {
         let validated = validate(msg.request.clone()).map_err(app::validation_error);
 
+        // 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 f = fut::result(validated).and_then(move |request, slf: &mut Self, _ctx| {
-            let params = types::DataReqParams {
-                request,
-                fee: msg.fee,
-            };
+            let params = types::DataReqParams { request, fee };
 
             slf.create_data_req(&msg.session_id, &msg.wallet_id, params)
                 .map_ok(

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

@@ -14,7 +14,7 @@ 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, TransactionHelper, VttOutputParamsHelper,
+        number_from_string, u32_to_string, FeeType, TransactionHelper, VttOutputParamsHelper,
     },
 };
 
@@ -29,6 +29,8 @@ pub struct VttOutputParams {
 pub struct CreateVttRequest {
     #[serde(deserialize_with = "deserialize_fee_backwards_compatible")]
     fee: Fee,
+    #[serde(default)]
+    fee_type: FeeType,
     label: Option<String>,
     #[serde(
         serialize_with = "into_generic_type_vec::<_, VttOutputParamsHelper, _>",
@@ -85,9 +87,13 @@ impl Handler<CreateVttRequest> for app::App {
         let validated =
             validate_output_addresses(testnet, &msg.outputs).map_err(app::validation_error);
 
+        // 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 f = fut::result(validated).and_then(move |outputs, act: &mut Self, _ctx| {
             let params = types::VttParams {
-                fee: msg.fee,
+                fee,
                 outputs,
                 utxo_strategy: msg.utxo_strategy.clone(),
                 selected_utxos: msg.selected_utxos.iter().map(|x| x.into()).collect(),

wallet/src/types.rs

@@ -277,6 +277,30 @@ pub struct SuperBlockNotification {
     pub consolidated_block_hashes: Vec<String>,
 }
 
+#[derive(Clone, Copy, Debug, Default, 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,
+        }
+    }
+}
+
 // Serialization helper
 
 /// Transaction data structure