crc: add utxo address field and improve test scenarios, #6250

Author: fdefelici

stacks-node/src/burnchains/rpc/bitcoin_rpc_client/mod.rs

@@ -31,6 +31,7 @@ use stacks::burnchains::bitcoin::address::BitcoinAddress;
 use stacks::burnchains::Txid;
 use stacks::config::Config;
 use stacks::types::chainstate::BurnchainHeaderHash;
+use stacks::types::Address;
 use stacks::util::hash::hex_bytes;
 use stacks_common::deps_common::bitcoin::blockdata::script::Script;
 use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction;
@@ -144,6 +145,9 @@ pub struct ListUnspentResponse {
     pub txid: Txid,
     /// The index of the output in the transaction.
     pub vout: u32,
+    /// The Bitcoin destination address
+    #[serde(deserialize_with = "deserialize_string_to_bitcoin_address")]
+    pub address: BitcoinAddress,
     /// The script associated with the output.
     #[serde(
         rename = "scriptPubKey",
@@ -168,6 +172,30 @@ where
     Ok(txid)
 }
 
+/// Deserializes a JSON string into [`BitcoinAddress`]
+fn deserialize_string_to_bitcoin_address<'de, D>(
+    deserializer: D,
+) -> Result<BitcoinAddress, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let addr_str: String = Deserialize::deserialize(deserializer)?;
+    if addr_str.starts_with("bcrt") {
+        //Currently BitcoinAddress doesn't manage Regtest HRP
+        return Err(serde::de::Error::custom(
+            "BitcoinAddress cannot manage Regtest HRP ('bcrt')",
+        ));
+    }
+
+    if let Some(addr) = BitcoinAddress::from_string(&addr_str) {
+        Ok(addr)
+    } else {
+        Err(serde::de::Error::custom(
+            "BitcoinAddress failed to create from string",
+        ))
+    }
+}
+
 /// Deserializes a JSON string into [`Script`]
 fn deserialize_string_to_script<'de, D>(deserializer: D) -> Result<Script, D::Error>
 where

stacks-node/src/burnchains/rpc/bitcoin_rpc_client/tests.rs

@@ -290,6 +290,7 @@ fn test_list_wallets_ok() {
 fn test_list_unspent_ok() {
     let expected_txid_str = utils::BITCOIN_TX1_TXID_HEX;
     let expected_script_hex = utils::BITCOIN_UTXO_SCRIPT_HEX;
+    let expected_address = utils::BITCOIN_ADDRESS_LEGACY_STR;
 
     let expected_request = json!({
         "jsonrpc": "2.0",
@@ -312,6 +313,7 @@ fn test_list_unspent_ok() {
         "result": [{
             "txid": expected_txid_str,
             "vout": 0,
+            "address": expected_address,
             "scriptPubKey": expected_script_hex,
             "amount": 0.00001,
             "confirmations": 6
@@ -347,6 +349,7 @@ fn test_list_unspent_ok() {
     let utxo = &result[0];
     assert_eq!(1_000, utxo.amount);
     assert_eq!(0, utxo.vout);
+    assert_eq!(expected_address, utxo.address.to_string());
     assert_eq!(6, utxo.confirmations);
     assert_eq!(expected_txid_str, utxo.txid.to_bitcoin_hex(),);
     assert_eq!(expected_script_hex, format!("{:x}", utxo.script_pub_key),);

stacks-node/src/tests/bitcoin_rpc_integrations.rs

@@ -322,7 +322,7 @@ fn test_generate_to_address_ok() {
 
 #[ignore]
 #[test]
-fn test_list_unspent_ok() {
+fn test_list_unspent_one_address_ok() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
     }
@@ -341,24 +341,104 @@ fn test_list_unspent_ok() {
         .get_new_address(None, Some(AddressType::Legacy))
         .expect("Should work!");
 
-    let utxos = client
+    let no_utxos = client
         .list_unspent(None, None, None, Some(false), Some(1), Some(10))
-        .expect("list_unspent should be ok!");
-    assert_eq!(0, utxos.len());
+        .expect("list_unspent empty should be ok!");
+    assert_eq!(0, no_utxos.len());
 
     _ = client
         .generate_to_address(102, &address)
         .expect("generate to address ok!");
 
-    let utxos = client
+    let all_utxos = client
         .list_unspent(None, None, None, Some(false), Some(1), Some(10))
-        .expect("list_unspent should be ok!");
-    assert_eq!(2, utxos.len());
+        .expect("all list_unspent should be ok!");
+    assert_eq!(2, all_utxos.len());
+    assert_eq!(address, all_utxos[0].address);
+    assert_eq!(address, all_utxos[1].address);
+
+    let addr_utxos = client
+        .list_unspent(
+            None,
+            None,
+            Some(&[&address]),
+            Some(false),
+            Some(1),
+            Some(10),
+        )
+        .expect("list_unspent per address should be ok!");
+    assert_eq!(2, addr_utxos.len());
+    assert_eq!(address, addr_utxos[0].address);
+    assert_eq!(address, addr_utxos[1].address);
 
-    let utxos = client
+    let max1_utxos = client
         .list_unspent(None, None, None, Some(false), Some(1), Some(1))
-        .expect("list_unspent should be ok!");
-    assert_eq!(1, utxos.len());
+        .expect("list_unspent per address and max count should be ok!");
+    assert_eq!(1, max1_utxos.len());
+    assert_eq!(address, max1_utxos[0].address);
+}
+
+#[ignore]
+#[test]
+fn test_list_unspent_two_addresses_ok() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let mut config = utils::create_stx_config();
+    config.burnchain.wallet_name = "my_wallet".to_string();
+
+    let mut btcd_controller = BitcoinCoreController::new(config.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("bitcoind should be started!");
+
+    let client = BitcoinRpcClient::from_stx_config(&config).expect("Client creation ok!");
+    client.create_wallet("my_wallet", Some(false)).expect("OK");
+    let address1 = client
+        .get_new_address(None, Some(AddressType::Legacy))
+        .expect("address 1 ok!");
+
+    let address2 = client
+        .get_new_address(None, Some(AddressType::Legacy))
+        .expect("address 2 ok!");
+
+    _ = client
+        .generate_to_address(2, &address1)
+        .expect("generate to address 1 ok!");
+    _ = client
+        .generate_to_address(101, &address2)
+        .expect("generate to address 2 ok!");
+
+    let all_utxos = client
+        .list_unspent(None, None, None, Some(false), None, None)
+        .expect("all list_unspent should be ok!");
+    assert_eq!(3, all_utxos.len());
+
+    let addr1_utxos = client
+        .list_unspent(None, None, Some(&[&address1]), Some(false), None, None)
+        .expect("list_unspent per address1 should be ok!");
+    assert_eq!(2, addr1_utxos.len());
+    assert_eq!(address1, addr1_utxos[0].address);
+    assert_eq!(address1, addr1_utxos[1].address);
+
+    let addr2_utxos = client
+        .list_unspent(None, None, Some(&[&address2]), Some(false), None, None)
+        .expect("list_unspent per address2 should be ok!");
+    assert_eq!(1, addr2_utxos.len());
+    assert_eq!(address2, addr2_utxos[0].address);
+
+    let all2_utxos = client
+        .list_unspent(
+            None,
+            None,
+            Some(&[&address1, &address2]),
+            Some(false),
+            None,
+            None,
+        )
+        .expect("all list_unspent for both addresses should be ok!");
+    assert_eq!(3, all2_utxos.len());
 }
 
 #[ignore]