Unify ListSinceBlock and ListTransactions item

Both RPCs return the same shape sub type. Including the changes in
versions between 17 and 29.

ListSinceBlockTransaction has all the changes implemented up to v29.

Use ListSinceBlockTransaction for both RPCs including the error and into
functions. Rename it to TransactionItem to be more general.

Remove ListTransactionsItem and associated error and into functions.

Author: jamillambert

integration_test/tests/wallet.rs

@@ -606,7 +606,7 @@ fn wallet__list_since_block__modelled() {
     let model: Result<mtype::ListSinceBlock, ListSinceBlockError> = json.into_model();
     let model = model.unwrap();
 
-    let first_tx: mtype::ListSinceBlockTransaction = model.transactions[0].clone();
+    let first_tx: mtype::TransactionItem = model.transactions[0].clone();
     assert_eq!(first_tx.txid.unwrap().to_string().len(), 64);
 }
 

types/src/model/mod.rs

@@ -58,10 +58,10 @@ pub use self::{
         GetTransactionDetail, GetUnconfirmedBalance, GetWalletInfo, GetWalletInfoScanning, HdKey,
         HdKeyDescriptor, LastProcessedBlock, ListAddressGroupings, ListAddressGroupingsItem,
         ListLockUnspent, ListLockUnspentItem, ListReceivedByAddress, ListReceivedByAddressItem,
-        ListReceivedByLabel, ListReceivedByLabelItem, ListSinceBlock, ListSinceBlockTransaction,
-        ListTransactions, ListTransactionsItem, ListUnspent, ListUnspentItem, ListWallets,
-        LoadWallet, PsbtBumpFee, RescanBlockchain, ScriptType, Send, SendAll, SendMany,
-        SendManyVerbose, SendToAddress, SignMessage, SimulateRawTransaction, TransactionCategory,
-        UnloadWallet, WalletCreateFundedPsbt, WalletDisplayAddress, WalletProcessPsbt,
+        ListReceivedByLabel, ListReceivedByLabelItem, ListSinceBlock, ListTransactions,
+        ListUnspent, ListUnspentItem, ListWallets, LoadWallet, PsbtBumpFee, RescanBlockchain,
+        ScriptType, Send, SendAll, SendMany, SendManyVerbose, SendToAddress, SignMessage,
+        SimulateRawTransaction, TransactionCategory, TransactionItem, UnloadWallet,
+        WalletCreateFundedPsbt, WalletDisplayAddress, WalletProcessPsbt,
     },
 };

types/src/model/wallet.rs

@@ -590,12 +590,12 @@ pub struct ListReceivedByLabelItem {
 #[serde(deny_unknown_fields)]
 pub struct ListSinceBlock {
     /// All the transactions.
-    pub transactions: Vec<ListSinceBlockTransaction>,
+    pub transactions: Vec<TransactionItem>,
     /// Only present if `include_removed=true`.
     ///
     /// Note: transactions that were re-added in the active chain will appear as-is in this array,
     /// and may thus have a positive confirmation count.
-    pub removed: Vec<ListSinceBlockTransaction>,
+    pub removed: Vec<TransactionItem>,
     /// The hash of the block (target_confirmations-1) from the best block on the main chain.
     ///
     /// This is typically used to feed back into listsinceblock the next time you call it. So you
@@ -604,11 +604,10 @@ pub struct ListSinceBlock {
     pub last_block: BlockHash,
 }
 
-/// Transaction list item, part of `ListSinceBlock`.
-// https://github.com/rust-bitcoin/rust-bitcoin/issues/3516
+/// Transaction item, part of `listsinceblock` and `listtransactions`.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ListSinceBlockTransaction {
+pub struct TransactionItem {
     /// Only returns true if imported addresses were involved in transaction.
     pub involves_watch_only: Option<bool>,
     /// The bitcoin address of the transaction.
@@ -690,58 +689,7 @@ pub struct ListSinceBlockTransaction {
 /// Models the result of JSON-RPC method `listtransactions`.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ListTransactions(pub Vec<ListTransactionsItem>);
-
-/// Transaction list item, part of `ListTransactions`.
-#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct ListTransactionsItem {
-    /// The bitcoin address of the transaction.
-    pub address: Address<NetworkUnchecked>,
-    /// The transaction category.
-    pub category: TransactionCategory,
-    /// The amount.
-    ///
-    /// This is negative for the 'send' category, and is positive for the 'receive' category.
-    #[serde(default, with = "bitcoin::amount::serde::as_btc")]
-    pub amount: SignedAmount,
-    /// A comment for the address/transaction, if any.
-    pub label: Option<String>,
-    /// The vout value.
-    pub vout: u32,
-    /// The amount of the fee in BTC.
-    ///
-    /// This is negative and only available for the 'send' category of transactions.
-    #[serde(default, with = "bitcoin::amount::serde::as_btc")]
-    pub fee: SignedAmount,
-    /// The number of confirmations for the transaction.
-    ///
-    /// Negative confirmations indicate the transaction conflicts with the block chain.
-    pub confirmations: i64,
-    /// Whether we consider the outputs of this unconfirmed transaction safe to spend.
-    pub trusted: bool,
-    /// The block hash containing the transaction.
-    pub block_hash: BlockHash,
-    /// The index of the transaction in the block that includes it.
-    pub block_index: u32,
-    /// The block time in seconds since epoch (1 Jan 1970 GMT).
-    pub block_time: u32,
-    /// The transaction id.
-    pub txid: Txid,
-    /// The transaction time in seconds since epoch (Jan 1 1970 GMT).
-    pub time: u32,
-    /// The time received in seconds since epoch (Jan 1 1970 GMT).
-    pub time_received: u32,
-    /// If a comment is associated with the transaction.
-    pub comment: Option<String>,
-    /// Whether this transaction could be replaced due to BIP125 (replace-by-fee);
-    /// may be unknown for unconfirmed transactions not in the mempool
-    pub bip125_replaceable: Bip125Replaceable,
-    /// If the transaction has been abandoned (inputs are respendable).
-    ///
-    /// Only available for the 'send' category of transactions.
-    pub abandoned: Option<bool>,
-}
+pub struct ListTransactions(pub Vec<TransactionItem>);
 
 /// Models the result of JSON-RPC method `listunspent`.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]

types/src/v17/mod.rs

@@ -281,8 +281,8 @@ pub use self::{
         ListAddressGroupingsError, ListAddressGroupingsItem, ListLabels, ListLockUnspent,
         ListLockUnspentItem, ListLockUnspentItemError, ListReceivedByAddress,
         ListReceivedByAddressError, ListReceivedByAddressItem, ListSinceBlock, ListSinceBlockError,
-        ListSinceBlockTransaction, ListSinceBlockTransactionError, ListTransactions,
-        ListTransactionsItem, ListTransactionsItemError, ListUnspent, ListUnspentItem,
+        ListTransactions,
+        TransactionItem, TransactionItemError, ListUnspent, ListUnspentItem,
         ListUnspentItemError, ListWallets, LoadWallet, LockUnspent, RescanBlockchain, ScriptType,
         SendMany, SendToAddress, SetTxFee, SignMessage, TransactionCategory,
         WalletCreateFundedPsbt, WalletCreateFundedPsbtError, WalletProcessPsbt,

types/src/v17/wallet/error.rs

@@ -496,9 +496,9 @@ impl std::error::Error for ListReceivedByAddressError {
 #[derive(Debug)]
 pub enum ListSinceBlockError {
     /// Conversion of item in `transactions` list failed.
-    Transactions(ListSinceBlockTransactionError),
+    Transactions(TransactionItemError),
     /// Conversion of item in `removed` list failed.
-    Removed(ListSinceBlockTransactionError),
+    Removed(TransactionItemError),
     /// Conversion of the `last_block` field failed.
     LastBlock(hex::HexToArrayError),
 }
@@ -529,9 +529,9 @@ impl std::error::Error for ListSinceBlockError {
     }
 }
 
-/// Error when converting a `ListSinceBlockTransaction` type into the model type.
+/// Error when converting a `TransactionItem` type into the model type.
 #[derive(Debug)]
-pub enum ListSinceBlockTransactionError {
+pub enum TransactionItemError {
     /// Conversion of numeric type to expected type failed.
     Numeric(NumericError),
     /// Conversion of the `address` field failed.
@@ -546,9 +546,9 @@ pub enum ListSinceBlockTransactionError {
     Txid(hex::HexToArrayError),
 }
 
-impl fmt::Display for ListSinceBlockTransactionError {
+impl fmt::Display for TransactionItemError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ListSinceBlockTransactionError as E;
+        use TransactionItemError as E;
 
         match *self {
             E::Numeric(ref e) => write_err!(f, "numeric"; e),
@@ -562,9 +562,9 @@ impl fmt::Display for ListSinceBlockTransactionError {
 }
 
 #[cfg(feature = "std")]
-impl std::error::Error for ListSinceBlockTransactionError {
+impl std::error::Error for TransactionItemError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ListSinceBlockTransactionError as E;
+        use TransactionItemError as E;
 
         match *self {
             E::Numeric(ref e) => Some(e),
@@ -577,59 +577,7 @@ impl std::error::Error for ListSinceBlockTransactionError {
     }
 }
 
-impl From<NumericError> for ListSinceBlockTransactionError {
-    fn from(e: NumericError) -> Self { Self::Numeric(e) }
-}
-
-/// Error when converting a `ListTransactionsItem` type into the model type.
-#[derive(Debug)]
-pub enum ListTransactionsItemError {
-    /// Conversion of numeric type to expected type failed.
-    Numeric(NumericError),
-    /// Conversion of the `address` field failed.
-    Address(address::ParseError),
-    /// Conversion of the `amount` field failed.
-    Amount(ParseAmountError),
-    /// Conversion of the `fee` field failed.
-    Fee(ParseAmountError),
-    /// Conversion of the `block_hash` field failed.
-    BlockHash(hex::HexToArrayError),
-    /// Conversion of the `txid` field failed.
-    Txid(hex::HexToArrayError),
-}
-
-impl fmt::Display for ListTransactionsItemError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ListTransactionsItemError as E;
-
-        match *self {
-            E::Numeric(ref e) => write_err!(f, "numeric"; e),
-            E::Address(ref e) => write_err!(f, "conversion of the `address` field failed"; e),
-            E::Amount(ref e) => write_err!(f, "conversion of the `amount` field failed"; e),
-            E::Fee(ref e) => write_err!(f, "conversion of the `fee` field failed"; e),
-            E::BlockHash(ref e) => write_err!(f, "conversion of the `block_hash` field failed"; e),
-            E::Txid(ref e) => write_err!(f, "conversion of the `txid` field failed"; e),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for ListTransactionsItemError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ListTransactionsItemError as E;
-
-        match *self {
-            E::Numeric(ref e) => Some(e),
-            E::Address(ref e) => Some(e),
-            E::Amount(ref e) => Some(e),
-            E::Fee(ref e) => Some(e),
-            E::BlockHash(ref e) => Some(e),
-            E::Txid(ref e) => Some(e),
-        }
-    }
-}
-
-impl From<NumericError> for ListTransactionsItemError {
+impl From<NumericError> for TransactionItemError {
     fn from(e: NumericError) -> Self { Self::Numeric(e) }
 }
 

types/src/v17/wallet/into.rs

@@ -578,12 +578,10 @@ impl ListSinceBlock {
     }
 }
 
-impl ListSinceBlockTransaction {
+impl TransactionItem {
     /// Converts version specific type to a version nonspecific, more strongly typed type.
-    pub fn into_model(
-        self,
-    ) -> Result<model::ListSinceBlockTransaction, ListSinceBlockTransactionError> {
-        use ListSinceBlockTransactionError as E;
+    pub fn into_model(self) -> Result<model::TransactionItem, TransactionItemError> {
+        use TransactionItemError as E;
 
         let address = self.address.parse::<Address<_>>().map_err(E::Address)?;
         let category = self.category.into_model();
@@ -599,7 +597,7 @@ impl ListSinceBlockTransaction {
         let txid = self.txid.map(|s| s.parse::<Txid>().map_err(E::Txid)).transpose()?;
         let bip125_replaceable = self.bip125_replaceable.into_model();
 
-        Ok(model::ListSinceBlockTransaction {
+        Ok(model::TransactionItem {
             involves_watch_only: None,
             address: Some(address),
             category,
@@ -633,50 +631,13 @@ impl ListSinceBlockTransaction {
 
 impl ListTransactions {
     /// Converts version specific type to a version nonspecific, more strongly typed type.
-    pub fn into_model(self) -> Result<model::ListTransactions, ListTransactionsItemError> {
+    pub fn into_model(self) -> Result<model::ListTransactions, TransactionItemError> {
         let transactions =
             self.0.into_iter().map(|tx| tx.into_model()).collect::<Result<Vec<_>, _>>()?;
         Ok(model::ListTransactions(transactions))
     }
 }
 
-impl ListTransactionsItem {
-    /// Converts version specific type to a version nonspecific, more strongly typed type.
-    pub fn into_model(self) -> Result<model::ListTransactionsItem, ListTransactionsItemError> {
-        use ListTransactionsItemError as E;
-
-        let address = self.address.parse::<Address<_>>().map_err(E::Address)?;
-        let category = self.category.into_model();
-        let amount = SignedAmount::from_btc(self.amount).map_err(E::Amount)?;
-        let vout = crate::to_u32(self.vout, "vout")?;
-        let fee = SignedAmount::from_btc(self.fee).map_err(E::Fee)?;
-        let block_hash = self.block_hash.parse::<BlockHash>().map_err(E::BlockHash)?;
-        let block_index = crate::to_u32(self.block_index, "block_index")?;
-        let txid = self.txid.parse::<Txid>().map_err(E::Txid)?;
-        let bip125_replaceable = self.bip125_replaceable.into_model();
-
-        Ok(model::ListTransactionsItem {
-            address,
-            category,
-            amount,
-            label: self.label,
-            vout,
-            fee,
-            confirmations: self.confirmations,
-            trusted: self.trusted,
-            block_hash,
-            block_index,
-            block_time: self.block_time,
-            txid,
-            time: self.time,
-            time_received: self.time_received,
-            comment: self.comment,
-            bip125_replaceable,
-            abandoned: self.abandoned,
-        })
-    }
-}
-
 impl ListUnspent {
     /// Converts version specific type to a version nonspecific, more strongly typed type.
     pub fn into_model(self) -> Result<model::ListUnspent, ListUnspentItemError> {