Test and update listsinceblock

The RPC was implemented for v17 and untested. Some fields are optional
or undocumented.

Fix the struct for v17. Update the struct, model, into_model, and error
for changes in v20, v23, v24 and v28.

Add a test and update the types tables.

Author: jamillambert

integration_test/tests/wallet.rs

@@ -593,6 +593,23 @@ fn wallet__list_received_by_address__modelled() {
     assert!(model.0.iter().any(|item| &item.address == unchecked_addr));
 }
 
+#[test]
+fn wallet__list_since_block__modelled() {
+    let node = Node::with_wallet(Wallet::Default, &[]);
+    node.fund_wallet();
+    let addr = node.client.new_address().expect("newaddress");
+    let amount = Amount::from_sat(5_000);
+    node.client.send_to_address(&addr, amount).expect("sendtoaddress");
+    node.mine_a_block();
+
+    let json: ListSinceBlock = node.client.list_since_block().expect("listsinceblock");
+    let model: Result<mtype::ListSinceBlock, ListSinceBlockError> = json.into_model();
+    let model = model.unwrap();
+
+    let first_tx: mtype::ListSinceBlockTransaction = model.transactions[0].clone();
+    assert_eq!(first_tx.txid.unwrap().to_string().len(), 64);
+}
+
 #[test]
 fn wallet__import_multi() {
     let node = match () {

types/src/model/wallet.rs

@@ -609,6 +609,8 @@ pub struct ListSinceBlock {
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct ListSinceBlockTransaction {
+    /// Only returns true if imported addresses were involved in transaction.
+    pub involves_watch_only: Option<bool>,
     /// The bitcoin address of the transaction.
     pub address: Option<Address<NetworkUnchecked>>,
     /// The transaction category.
@@ -631,39 +633,58 @@ pub struct ListSinceBlockTransaction {
     /// Available for 'send' and 'receive' category of transactions. When it's < 0, it means the
     /// transaction conflicted that many blocks ago.
     pub confirmations: i64,
+    /// Only present if the transaction's only input is a coinbase one. Only documented from v0.20 and later.
+    pub generated: Option<bool>,
+    /// Whether we consider the transaction to be trusted and safe to spend from. Only present
+    /// when the transaction has 0 confirmations (or negative confirmations, if conflicted). v0.20 and later only.
+    pub trusted: Option<bool>,
     /// The block hash containing the transaction.
     ///
     /// Available for 'send' and 'receive' category of transactions.
-    pub block_hash: BlockHash,
+    pub block_hash: Option<BlockHash>,
+    /// The block height containing the transaction. v20 and later only.
+    pub block_height: Option<u32>,
     /// The index of the transaction in the block that includes it.
     ///
     /// Available for 'send' and 'receive' category of transactions.
-    pub block_index: u32,
+    pub block_index: Option<u32>,
     /// The block time in seconds since epoch (1 Jan 1970 GMT).
-    pub block_time: u32,
+    pub block_time: Option<u32>,
     /// The transaction id.
     ///
     /// Available for 'send' and 'receive' category of transactions.
     pub txid: Option<Txid>,
+    /// The hash of serialized transaction, including witness data. v24 and later only.
+    pub wtxid: Option<Txid>,
+    /// Conflicting transaction ids. Only documented from v0.20 and later.
+    pub wallet_conflicts: Option<Vec<Txid>>,
+    /// The txid if this tx was replaced. v23 and later only.
+    pub replaced_by_txid: Option<Txid>,
+    /// The txid if this tx replaces one. v23 and later only.
+    pub replaces_txid: Option<Txid>,
+    /// Transactions in the mempool that directly conflict with either this transaction or an ancestor transaction. v28 and later only.
+    pub mempool_conflicts: Option<Vec<Txid>>,
+    /// If a comment to is associated with the transaction.
+    pub to: Option<String>,
     /// 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).
     ///
     /// Available for 'send' and 'receive' category of transactions.
     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,
+    /// Only if 'category' is 'received'. List of parent descriptors for the scriptPubKey of this coin. v24 and later only.
+    pub parent_descriptors: Option<Vec<String>>,
     /// If the transaction has been abandoned (inputs are respendable).
     ///
     /// Only available for the 'send' category of transactions.
     pub abandoned: Option<bool>,
-    /// If a comment is associated with the transaction.
-    pub comment: Option<String>,
     /// A comment for the address/transaction, if any.
     pub label: Option<String>,
-    /// If a comment to is associated with the transaction.
-    pub to: Option<String>,
 }
 
 /// Models the result of JSON-RPC method `listtransactions`.

types/src/v17/mod.rs

@@ -185,7 +185,7 @@
 //! | listlockunspent                    | version + model |                                        |
 //! | listreceivedbyaccount              | returns nothing |                                        |
 //! | listreceivedbyaddress              | version + model |                                        |
-//! | listsinceblock                     | version + model | UNTESTED                               |
+//! | listsinceblock                     | version + model |                                        |
 //! | listtransactions                   | version + model | UNTESTED                               |
 //! | listunspent                        | version + model |                                        |
 //! | listwallets                        | version + model |                                        |

types/src/v17/wallet/into.rs

@@ -589,30 +589,44 @@ impl ListSinceBlockTransaction {
         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 fee = self
+            .fee
+            .map(|f| SignedAmount::from_btc(f).map_err(E::Fee))
+            .transpose()? // optional historically
+            .unwrap_or_else(|| SignedAmount::from_sat(0));
         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.map(|s| s.parse::<Txid>().map_err(E::Txid)).transpose()?;
         let bip125_replaceable = self.bip125_replaceable.into_model();
 
         Ok(model::ListSinceBlockTransaction {
+            involves_watch_only: None,
             address: Some(address),
             category,
             amount,
             vout,
             fee,
             confirmations: self.confirmations,
-            block_hash,
-            block_index,
-            block_time: self.block_time,
+            block_hash: Some(block_hash),
+            block_index: Some(block_index),
+            block_time: Some(self.block_time),
             txid,
+            wtxid: None,
             time: self.time,
             time_received: self.time_received,
             bip125_replaceable,
+            generated: None,
+            trusted: None,
             abandoned: self.abandoned,
             comment: self.comment,
             label: self.label,
             to: self.to,
+            block_height: None,
+            wallet_conflicts: None,
+            replaced_by_txid: None,
+            replaces_txid: None,
+            mempool_conflicts: None,
+            parent_descriptors: None,
         })
     }
 }

types/src/v17/wallet/mod.rs

@@ -716,7 +716,7 @@ pub struct ListSinceBlock {
 #[serde(deny_unknown_fields)]
 pub struct ListSinceBlockTransaction {
     /// DEPRECATED. The account name associated with the transaction. Will be "" for the default account.
-    pub account: String,
+    pub account: Option<String>,
     /// The bitcoin address of the transaction.
     ///
     /// Not present for move transactions (category = move).
@@ -734,12 +734,14 @@ pub struct ListSinceBlockTransaction {
     /// The amount of the fee in BTC.
     ///
     /// This is negative and only available for the 'send' category of transactions.
-    pub fee: f64,
+    pub fee: Option<f64>,
     /// The number of confirmations for the transaction.
     ///
     /// Available for 'send' and 'receive' category of transactions. When it's < 0, it means the
     /// transaction conflicted that many blocks ago.
     pub confirmations: i64,
+    /// Only present if transaction only input is a coinbase one.
+    pub generated: Option<bool>,
     /// The block hash containing the transaction.
     ///
     /// Available for 'send' and 'receive' category of transactions.
@@ -757,6 +759,9 @@ pub struct ListSinceBlockTransaction {
     ///
     /// Available for 'send' and 'receive' category of transactions.
     pub txid: Option<String>,
+    /// Conflicting transaction ids.
+    #[serde(rename = "walletconflicts")]
+    pub wallet_conflicts: Vec<String>,
     /// 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).

types/src/v18/mod.rs

@@ -188,7 +188,7 @@
 //! | listlockunspent                    | version + model |                                        |
 //! | listreceivedbyaddress              | version + model |                                        |
 //! | listreceivedbylabel                | version + model |                                        |
-//! | listsinceblock                     | version + model | UNTESTED                               |
+//! | listsinceblock                     | version + model |                                        |
 //! | listtransactions                   | version + model | UNTESTED                               |
 //! | listunspent                        | version + model |                                        |
 //! | listwalletdir                      | version         |                                        |

types/src/v19/mod.rs

@@ -189,7 +189,7 @@
 //! | listlockunspent                    | version + model |                                        |
 //! | listreceivedbyaddress              | version + model |                                        |
 //! | listreceivedbylabel                | version + model |                                        |
-//! | listsinceblock                     | version + model | UNTESTED                               |
+//! | listsinceblock                     | version + model |                                        |
 //! | listtransactions                   | version + model | UNTESTED                               |
 //! | listunspent                        | version + model |                                        |
 //! | listwalletdir                      | version         |                                        |

types/src/v20/mod.rs

@@ -190,7 +190,7 @@
 //! | listlockunspent                    | version + model |                                        |
 //! | listreceivedbyaddress              | version + model |                                        |
 //! | listreceivedbylabel                | version + model |                                        |
-//! | listsinceblock                     | version + model | UNTESTED                               |
+//! | listsinceblock                     | version + model |                                        |
 //! | listtransactions                   | version + model | UNTESTED                               |
 //! | listunspent                        | version + model |                                        |
 //! | listwalletdir                      | version         |                                        |
@@ -240,7 +240,8 @@ pub use self::{
     util::CreateMultisig,
     wallet::{
         AddMultisigAddress, GetAddressInfo, GetAddressInfoEmbedded, GetTransaction,
-        GetTransactionDetail,
+        GetTransactionDetail, ListSinceBlock, ListSinceBlockError, ListSinceBlockTransaction,
+        ListSinceBlockTransactionError,
     },
 };
 #[doc(inline)]
@@ -264,8 +265,7 @@ pub use crate::{
         GetTransactionDetailError, GetTransactionError, GetTxOut, GetTxOutError, GetTxOutSetInfo,
         GetTxOutSetInfoError, GetUnconfirmedBalance, GetWalletInfoError, ListAddressGroupings,
         ListAddressGroupingsError, ListAddressGroupingsItem, ListLabels, ListLockUnspent,
-        ListLockUnspentItem, ListLockUnspentItemError, ListReceivedByAddressError, ListSinceBlock,
-        ListSinceBlockError, ListSinceBlockTransaction, ListSinceBlockTransactionError,
+        ListLockUnspentItem, ListLockUnspentItemError, ListReceivedByAddressError,
         ListTransactions, ListTransactionsItem, ListTransactionsItemError, ListUnspentItemError,
         ListWallets, LoadWallet, LockUnspent, Locked, PruneBlockchain, RawTransactionError,
         RawTransactionInput, RawTransactionOutput, RescanBlockchain, ScriptType, SendMany,

types/src/v20/wallet/error.rs

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Errors for wallet types newly (re)defined in v20.
+
+use core::fmt;
+
+use bitcoin::amount::ParseAmountError;
+use bitcoin::{address, hex};
+
+use crate::error::write_err;
+use crate::NumericError;
+
+/// Error when converting a `ListSinceBlock` type into the model type.
+#[derive(Debug)]
+pub enum ListSinceBlockError {
+    /// Conversion of item in `transactions` list failed.
+    Transactions(ListSinceBlockTransactionError),
+    /// Conversion of item in `removed` list failed.
+    Removed(ListSinceBlockTransactionError),
+    /// Conversion of the `last_block` field failed.
+    LastBlock(hex::HexToArrayError),
+}
+
+impl fmt::Display for ListSinceBlockError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use ListSinceBlockError::*;
+
+        match *self {
+            Transactions(ref e) =>
+                write_err!(f, "conversion of the `transactions` field failed"; e),
+            Removed(ref e) => write_err!(f, "conversion of the `removed` field failed"; e),
+            LastBlock(ref e) => write_err!(f, "conversion of the `last_block` field failed"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ListSinceBlockError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use ListSinceBlockError::*;
+
+        match *self {
+            Transactions(ref e) => Some(e),
+            Removed(ref e) => Some(e),
+            LastBlock(ref e) => Some(e),
+        }
+    }
+}
+
+/// Error when converting a `ListSinceBlockTransaction` type into the model type.
+///
+/// Note: Additional fields introduced in v20 (e.g. `generated`, `trusted`, `block_height`,
+/// `wallet_conflicts`, `involvesWatchonly`) are currently not modelled and therefore are
+/// intentionally ignored during conversion; as such they have no dedicated error variants.
+#[derive(Debug)]
+pub enum ListSinceBlockTransactionError {
+    /// 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),
+    /// Conversion of an item in the `wallet_conflicts` list failed.
+    WalletConflicts(hex::HexToArrayError),
+}
+
+impl fmt::Display for ListSinceBlockTransactionError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use ListSinceBlockTransactionError 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),
+            E::WalletConflicts(ref e) =>
+                write_err!(f, "conversion of an item in the `wallet_conflicts` list failed"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ListSinceBlockTransactionError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use ListSinceBlockTransactionError 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),
+            E::WalletConflicts(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<NumericError> for ListSinceBlockTransactionError {
+    fn from(e: NumericError) -> Self { Self::Numeric(e) }
+}