f Don't use rust-bitcoin types in non-model

Author: tnull

integration_test/src/v28/raw_transactions.rs

@@ -65,6 +65,8 @@ macro_rules! impl_test_v28__submitpackage {
             let res = bitcoind
                 .client
                 .submit_package(&[tx_0, tx_1], None, None)
+                .expect("failed to submit package")
+                .into_model()
                 .expect("failed to submit package");
             for (_, tx_result) in &res.tx_results {
                 assert!(tx_result.error.is_some());

json/src/model/mod.rs

@@ -35,7 +35,8 @@ pub use self::{
     generating::{Generate, GenerateToAddress},
     network::{GetNetworkInfo, GetNetworkInfoAddress, GetNetworkInfoNetwork},
     raw_transactions::{
-        SendRawTransaction, SubmitPackage, SubmitPackageTxResult, SubmitPackageTxResultFees,
+        SendRawTransaction, SubmitPackage, SubmitPackageError, SubmitPackageTxResult,
+        SubmitPackageTxResultFees,
     },
     wallet::{
         CreateWallet, GetBalance, GetBalances, GetBalancesMine, GetBalancesWatchOnly,

json/src/model/raw_transactions.rs

@@ -7,6 +7,8 @@
 
 use std::collections::HashMap;
 
+use bitcoin::amount::ParseAmountError;
+use bitcoin::hex::HexToArrayError;
 use bitcoin::{Amount, FeeRate, Txid, Wtxid};
 
 /// Models the result of JSON-RPC method `sendrawtransaction`.
@@ -55,3 +57,16 @@ pub struct SubmitPackageTxResultFees {
     /// whose fees and vsizes are included in effective-feerate.
     pub effective_includes: Vec<Wtxid>,
 }
+
+/// Error when converting a `SubmitPackageTxResultFees` type into the model type.
+#[derive(Debug)]
+pub enum SubmitPackageError {
+    /// Conversion of a `Txid` failed.
+    Txid(HexToArrayError),
+    /// Conversion of a `Wtxid` failed.
+    Wtxid(HexToArrayError),
+    /// Conversion of the `base_fee` field failed.
+    BaseFee(ParseAmountError),
+    /// Conversion of the `vsize` field failed.
+    Vsize,
+}

json/src/v28/raw_transactions.rs

@@ -5,11 +5,12 @@
 //! Types for methods found under the `== Rawtransactions ==` section of the API docs.
 
 use std::collections::HashMap;
+use std::str::FromStr;
 
 use bitcoin::{Amount, FeeRate, Txid, Wtxid};
 use serde::{Deserialize, Serialize};
 
-use crate::model;
+use crate::model::{self, SubmitPackageError};
 
 /// Result of JSON-RPC method `submitpackage`.
 //submitpackage ["rawtx",...] ( maxfeerate maxburnamount )
@@ -70,20 +71,33 @@ pub struct SubmitPackage {
     pub package_msg: String,
     /// Transaction results keyed by [`Wtxid`].
     #[serde(rename = "tx-results")]
-    pub tx_results: HashMap<Wtxid, SubmitPackageTxResult>,
+    pub tx_results: HashMap<String, SubmitPackageTxResult>,
     /// List of txids of replaced transactions.
     #[serde(rename = "replaced-transactions")]
-    pub replaced_transactions: Vec<Txid>,
+    pub replaced_transactions: Vec<String>,
 }
 
 impl SubmitPackage {
     /// Converts version specific type to a version in-specific, more strongly typed type.
-    pub fn into_model(self) -> model::SubmitPackage {
-        model::SubmitPackage {
-            package_msg: self.package_msg,
-            tx_results: self.tx_results.into_iter().map(|(k, v)| (k, v.into_model())).collect(),
-            replaced_transactions: self.replaced_transactions,
+    pub fn into_model(self) -> Result<model::SubmitPackage, model::SubmitPackageError> {
+        let mut tx_results = HashMap::with_capacity(self.tx_results.len());
+        for (k, v) in self.tx_results {
+            let wtxid = Wtxid::from_str(&k).map_err(model::SubmitPackageError::Wtxid)?;
+            let result = v.into_model()?;
+            tx_results.insert(wtxid, result);
+        }
+
+        let mut replaced_transactions = Vec::with_capacity(self.replaced_transactions.len());
+        for t in self.replaced_transactions {
+            let txid = Txid::from_str(&t).map_err(model::SubmitPackageError::Txid)?;
+            replaced_transactions.push(txid);
         }
+
+        Ok(model::SubmitPackage {
+            package_msg: self.package_msg,
+            tx_results,
+            replaced_transactions,
+        })
     }
 }
 
@@ -96,9 +110,9 @@ pub struct SubmitPackageTxResult {
     ///
     /// If set, this means the submitted transaction was ignored.
     #[serde(rename = "other-wtxid")]
-    pub other_wtxid: Option<Wtxid>,
+    pub other_wtxid: Option<String>,
     /// Sigops-adjusted virtual transaction size.
-    pub vsize: Option<usize>,
+    pub vsize: Option<i64>,
     /// Transaction fees.
     pub fees: Option<SubmitPackageTxResultFees>,
     /// The transaction error string, if it was rejected by the mempool
@@ -107,14 +121,26 @@ pub struct SubmitPackageTxResult {
 
 impl SubmitPackageTxResult {
     /// Converts version specific type to a version in-specific, more strongly typed type.
-    pub fn into_model(self) -> model::SubmitPackageTxResult {
-        model::SubmitPackageTxResult {
+    pub fn into_model(self) -> Result<model::SubmitPackageTxResult, model::SubmitPackageError> {
+        let other_wtxid = if let Some(other_wtxid) = self.other_wtxid {
+            Some(Wtxid::from_str(&other_wtxid).map_err(SubmitPackageError::Wtxid)?)
+        } else {
+            None
+        };
+
+        let vsize = if let Some(vsize) = self.vsize {
+            Some(vsize.try_into().map_err(|_| SubmitPackageError::Vsize)?)
+        } else {
+            None
+        };
+        let fees = if let Some(fees) = self.fees { Some(fees.into_model()?) } else { None };
+        Ok(model::SubmitPackageTxResult {
             txid: self.txid,
-            other_wtxid: self.other_wtxid,
-            vsize: self.vsize,
-            fees: self.fees.map(move |f| f.into_model()),
+            other_wtxid,
+            vsize,
+            fees,
             error: self.error,
-        }
+        })
     }
 }
 
@@ -123,27 +149,41 @@ impl SubmitPackageTxResult {
 pub struct SubmitPackageTxResultFees {
     /// Transaction fee.
     #[serde(rename = "base")]
-    pub base_fee: Amount,
+    pub base_fee: f64,
     /// The effective feerate.
     ///
     /// Will be `None` if the transaction was already in the mempool.
     ///
     /// For example, the package feerate and/or feerate with modified fees from the `prioritisetransaction` JSON-RPC method.
     #[serde(rename = "effective-feerate")]
-    pub effective_feerate: Option<FeeRate>,
+    pub effective_feerate: Option<f64>,
     /// If [`Self::effective_feerate`] is provided, this holds the [`Wtxid`]s of the transactions
     /// whose fees and vsizes are included in effective-feerate.
     #[serde(rename = "effective-includes")]
-    pub effective_includes: Vec<Wtxid>,
+    pub effective_includes: Vec<String>,
 }
 
 impl SubmitPackageTxResultFees {
     /// Converts version specific type to a version in-specific, more strongly typed type.
-    pub fn into_model(self) -> model::SubmitPackageTxResultFees {
-        model::SubmitPackageTxResultFees {
-            base_fee: self.base_fee,
-            effective_feerate: self.effective_feerate,
-            effective_includes: self.effective_includes,
+    pub fn into_model(self) -> Result<model::SubmitPackageTxResultFees, model::SubmitPackageError> {
+        let mut effective_includes = Vec::with_capacity(self.effective_includes.len());
+        for include in self.effective_includes {
+            let wtxid = Wtxid::from_str(&include).map_err(SubmitPackageError::Wtxid)?;
+            effective_includes.push(wtxid);
         }
+
+        let effective_feerate = self.effective_feerate.map(|rate_btc_kvb| {
+            // Bitcoin Core gives us a feerate in BTC/KvB.
+            // Thus, we multiply by 25_000_000 (10^8 / 4) to get satoshis/kwu.
+            let fee_rate_sat_per_kwu = (rate_btc_kvb * 25_000_000.0).round() as u64;
+            FeeRate::from_sat_per_kwu(fee_rate_sat_per_kwu)
+        });
+
+        Ok(model::SubmitPackageTxResultFees {
+            base_fee: Amount::from_btc(self.base_fee)
+                .map_err(model::SubmitPackageError::BaseFee)?,
+            effective_feerate,
+            effective_includes,
+        })
     }
 }