bitcoind: import Miniscript descriptors instead of addresses

- Don't generate a set of addresses to be imported, import the ranged
  Miniscript descriptors directly.
- Tell listsinceblock to list change, too (custom bitcoind patch). This
  is necessary because deposit addresses aren't part of bitcoind's
  address book anymore and we would otherwise fail to detect some
  deposits.
- Use the 'wallet_desc' field in listsinceblock entries to track coins,
  instead of the former labels imported along with the addresses.

This also cleans up the descriptor import routines.

Author: darosior

src/bitcoind/interface.rs

@@ -24,11 +24,6 @@ use serde_json::Value as Json;
 // If bitcoind takes more than 3 minutes to answer one of our queries, fail.
 const RPC_SOCKET_TIMEOUT: u64 = 180;
 
-// Labels used to tag utxos in the watchonly wallet
-const DEPOSIT_UTXOS_LABEL: &str = "revault-deposit";
-const UNVAULT_UTXOS_LABEL: &str = "revault-unvault";
-const CPFP_UTXOS_LABEL: &str = "revault-cpfp";
-
 pub struct BitcoinD {
     node_client: Client,
     watchonly_client: Client,
@@ -350,32 +345,14 @@ impl BitcoinD {
         }
     }
 
-    /// Constructs an `addr()` descriptor out of an address
-    pub fn addr_descriptor(&self, address: &str) -> Result<String, BitcoindError> {
-        let desc_wo_checksum = format!("addr({})", address);
-
-        Ok(self
-            .make_watchonly_request(
-                "getdescriptorinfo",
-                &params!(Json::String(desc_wo_checksum)),
-            )?
-            .get("descriptor")
-            .expect("No 'descriptor' in 'getdescriptorinfo'")
-            .as_str()
-            .expect("'descriptor' in 'getdescriptorinfo' isn't a string anymore")
-            .to_string())
-    }
-
-    fn bulk_import_descriptors(
+    fn import_descriptors(
         &self,
         client: &Client,
         descriptors: Vec<String>,
-        timestamp: u32,
-        label: String,
-        fresh_wallet: bool,
+        timestamp: Option<u32>,
         active: bool,
     ) -> Result<(), BitcoindError> {
-        if !fresh_wallet {
+        if timestamp.is_some() {
             log::debug!("Not a fresh wallet, rescan *may* take some time.");
         }
 
@@ -388,13 +365,11 @@ impl BitcoinD {
                 // will rescan the last few blocks for each of them.
                 desc_map.insert(
                     "timestamp".to_string(),
-                    if fresh_wallet {
-                        Json::String("now".to_string())
-                    } else {
-                        Json::Number(serde_json::Number::from(timestamp))
-                    },
+                    timestamp
+                        .map(serde_json::Number::from)
+                        .map(Json::Number)
+                        .unwrap_or_else(|| Json::String("now".to_string())),
                 );
-                desc_map.insert("label".to_string(), Json::String(label.clone()));
                 desc_map.insert("active".to_string(), Json::Bool(active));
 
                 Json::Object(desc_map)
@@ -424,84 +399,26 @@ impl BitcoinD {
         )))
     }
 
-    pub fn startup_import_deposit_descriptors(
-        &self,
-        descriptors: Vec<String>,
-        timestamp: u32,
-        fresh_wallet: bool,
-    ) -> Result<(), BitcoindError> {
-        self.bulk_import_descriptors(
-            &self.watchonly_client,
-            descriptors,
-            timestamp,
-            DEPOSIT_UTXOS_LABEL.to_string(),
-            fresh_wallet,
-            false,
-        )
-    }
-
-    pub fn startup_import_unvault_descriptors(
+    /// Import the deposit and Unvault descriptors, when at startup.
+    pub fn startup_import_descriptors(
         &self,
-        descriptors: Vec<String>,
-        timestamp: u32,
-        fresh_wallet: bool,
+        descriptors: [String; 2],
+        timestamp: Option<u32>,
     ) -> Result<(), BitcoindError> {
-        self.bulk_import_descriptors(
+        self.import_descriptors(
             &self.watchonly_client,
-            descriptors,
+            descriptors.to_vec(),
             timestamp,
-            UNVAULT_UTXOS_LABEL.to_string(),
-            fresh_wallet,
             false,
         )
     }
 
-    pub fn startup_import_cpfp_descriptor(
-        &self,
-        descriptor: String,
-        timestamp: u32,
-        fresh_wallet: bool,
-    ) -> Result<(), BitcoindError> {
-        self.bulk_import_descriptors(
-            &self.cpfp_client,
-            vec![descriptor],
-            timestamp,
-            CPFP_UTXOS_LABEL.to_string(),
-            fresh_wallet,
-            true,
-        )
-    }
-
-    fn import_fresh_descriptor(
+    pub fn import_cpfp_descriptor(
         &self,
         descriptor: String,
-        label: String,
+        timestamp: Option<u32>,
     ) -> Result<(), BitcoindError> {
-        let mut desc_map = serde_json::Map::with_capacity(3);
-        desc_map.insert("desc".to_string(), Json::String(descriptor));
-        desc_map.insert("timestamp".to_string(), Json::String("now".to_string()));
-        desc_map.insert("label".to_string(), Json::String(label));
-
-        let res = self.make_watchonly_request(
-            "importdescriptors",
-            &params!(Json::Array(vec![Json::Object(desc_map,)])),
-        )?;
-        if res.get(0).map(|x| x.get("success")).flatten() == Some(&Json::Bool(true)) {
-            return Ok(());
-        }
-
-        Err(BitcoindError::Custom(format!(
-            "In import_fresh descriptor, no success returned from 'importdescriptor': {:?}",
-            res
-        )))
-    }
-
-    pub fn import_fresh_deposit_descriptor(&self, descriptor: String) -> Result<(), BitcoindError> {
-        self.import_fresh_descriptor(descriptor, DEPOSIT_UTXOS_LABEL.to_string())
-    }
-
-    pub fn import_fresh_unvault_descriptor(&self, descriptor: String) -> Result<(), BitcoindError> {
-        self.import_fresh_descriptor(descriptor, UNVAULT_UTXOS_LABEL.to_string())
+        self.import_descriptors(&self.cpfp_client, vec![descriptor], timestamp, true)
     }
 
     pub fn list_unspent_cpfp(&self) -> Result<Vec<ListUnspentEntry>, BitcoindError> {
@@ -559,15 +476,21 @@ impl BitcoinD {
     fn list_since_block(
         &self,
         tip: &BlockchainTip,
-        label: Option<&'static str>,
+        descriptor: Option<String>,
     ) -> Result<Vec<ListSinceBlockTransaction>, BitcoindError> {
         let req = if tip.height == 0 {
             self.make_request(&self.watchonly_client, "listsinceblock", &params!())?
         } else {
             self.make_request(
                 &self.watchonly_client,
                 "listsinceblock",
-                &params!(Json::String(tip.hash.to_string())),
+                &params!(
+                    Json::String(tip.hash.to_string()),
+                    Json::Number(1.into()),
+                    Json::Bool(true),
+                    Json::Bool(true),
+                    Json::Bool(true)
+                ),
             )?
         };
         Ok(req
@@ -578,20 +501,26 @@ impl BitcoinD {
             .iter()
             .filter_map(|t| {
                 let t = ListSinceBlockTransaction::from(t);
-                if label.or_else(|| t.label.as_deref()) == t.label.as_deref() {
-                    Some(t)
-                } else {
-                    None
+                match descriptor {
+                    None => Some(t),
+                    Some(ref desc) => {
+                        if t.wallet_descs.contains(desc) {
+                            Some(t)
+                        } else {
+                            None
+                        }
+                    }
                 }
             })
             .collect())
     }
 
-    pub fn list_deposits_since_block(
+    fn list_deposits_since_block(
         &self,
         tip: &BlockchainTip,
+        deposit_desc: String,
     ) -> Result<Vec<ListSinceBlockTransaction>, BitcoindError> {
-        self.list_since_block(tip, Some(DEPOSIT_UTXOS_LABEL))
+        self.list_since_block(tip, Some(deposit_desc))
     }
 
     /// Repeatedly called by our main loop to stay in sync with bitcoind.
@@ -601,6 +530,7 @@ impl BitcoinD {
         deposits_utxos: &HashMap<OutPoint, UtxoInfo>,
         db_tip: &BlockchainTip,
         min_conf: u32,
+        deposit_desc: String,
     ) -> Result<DepositsState, BitcoindError> {
         let (mut new_unconf, mut new_conf, mut new_spent) =
             (HashMap::new(), HashMap::new(), HashMap::new());
@@ -645,7 +575,7 @@ impl BitcoinD {
         }
 
         // Second, we scan for new ones.
-        let utxos = self.list_deposits_since_block(db_tip)?;
+        let utxos = self.list_deposits_since_block(db_tip, deposit_desc)?;
         for utxo in utxos {
             if utxo.is_receive && deposits_utxos.get(&utxo.outpoint).is_none() {
                 new_unconf.insert(
@@ -850,9 +780,6 @@ impl BitcoinD {
                 continue;
             }
 
-            // TODO: i think we can also filter out the entries *with* a "revault-somthing" label,
-            // but we need to be sure.
-
             let spending_txid = transaction
                 .get("txid")
                 .map(|t| t.as_str())
@@ -1169,7 +1096,7 @@ pub struct ListSinceBlockTransaction {
     pub outpoint: OutPoint,
     pub txo: TxOut,
     pub is_receive: bool,
-    pub label: Option<String>,
+    pub wallet_descs: Vec<String>,
     pub confirmations: i32,
     pub blockheight: Option<u32>,
 }
@@ -1225,19 +1152,31 @@ impl From<&Json> for ListSinceBlockTransaction {
             .map(|a| a.as_u64())
             .flatten()
             .map(|b| b as u32);
-        let label = j
-            .get("label")
-            .map(|l| l.as_str())
-            .flatten()
-            .map(|l| l.to_string());
+        // FIXME: allocs
+        let wallet_descs = j
+            .get("wallet_descs")
+            .map(|l| {
+                l.as_array()
+                    .expect(
+                        "API break, 'listsinceblock' entry didn't contain a valid 'wallet_descs'.",
+                    )
+                    .iter()
+                    .map(|desc| {
+                        desc.as_str()
+                            .expect("Invalid desc string in 'listsinceblock'.")
+                            .to_string()
+                    })
+                    .collect()
+            })
+            .unwrap_or_else(|| Vec::new());
 
         ListSinceBlockTransaction {
             outpoint: OutPoint {
                 txid,
                 vout: vout as u32, // Bitcoin makes this safe
             },
             is_receive,
-            label,
+            wallet_descs,
             txo: TxOut {
                 value,
                 script_pubkey,