[WIP_DO_NOT_MERGE] Add outpoint subscribe method

src/electrum.rs

@@ -2,7 +2,7 @@ use anyhow::{bail, Context, Result};
 use bitcoin::{
     consensus::{deserialize, serialize},
     hashes::hex::{FromHex, ToHex},
-    BlockHash, Txid,
+    BlockHash, OutPoint, Transaction, Txid,
 };
 use rayon::prelude::*;
 use serde_derive::Deserialize;
@@ -275,6 +275,71 @@ impl Rpc {
         Ok(status)
     }
 
+    fn outpoint_subscribe(&self, (txid, vout): (Txid, u32)) -> Result<Value> {
+        let funding = OutPoint { txid, vout };
+
+        let funding_blockhash = self.tracker.get_blockhash_by_txid(funding.txid);
+        let spending_blockhash = self.tracker.get_blockhash_spending_by_outpoint(funding);
+
+        let mut funding_inputs_confirmed = true;
+
+        let funding_tx =  match self.daemon.get_transaction(&funding.txid, funding_blockhash) {
+            Ok(tx) => tx,
+            Err(_) => return Ok(json!({})),
+        };
+
+        let funding_inputs = &funding_tx.input;
+
+        if funding_blockhash.is_none() && funding_inputs.iter().any(|txi| self.tracker.get_blockhash_by_txid(txi.previous_output.txid).is_none()) {
+            funding_inputs_confirmed = false;
+        }
+
+        let funding_height = match &funding_blockhash {
+            Some(funding_blockhash) => self.tracker.chain().get_block_height(funding_blockhash).ok_or_else(|| anyhow::anyhow!("Blockhash not found"))?,
+            None => 0,
+        };
+
+        let tx_candidates: Vec<Txid> = match spending_blockhash {
+            None => self.tracker.mempool().filter_by_spending(&funding).iter().map(|e| e.txid).collect(),
+            Some(spending_blockhash) => {
+                let mut txids: Vec<Txid> = Vec::new();
+                self.daemon.for_blocks(Some(spending_blockhash).into_iter(), |_, block| {
+                    for tx in block.txdata.into_iter() {
+                        if is_spending(&tx, funding) {
+                            txids.push(tx.txid())
+                        }
+                    }
+                })?;
+                txids
+            },
+        };
+
+        let mut spender_txids = tx_candidates.iter();
+
+        match spender_txids.next() {
+            Some(spender_txid) => if let Some(double_spending_txid) = spender_txids.next() {
+                    return bail!("double spend of {}: {}", spender_txid, double_spending_txid)
+                } else {
+                    match spending_blockhash {
+                        Some(spending_blockhash) => {
+                            let spending_height = self.tracker.chain().get_block_height(&spending_blockhash).ok_or_else(|| anyhow::anyhow!("Blockhash not found"))?;
+                            return Ok(json!({"height": funding_height, "spender_txhash": spender_txid, "spender_height": spending_height}))
+                        }
+                        None => {
+                            let spending_tx = self.daemon.get_transaction(&spender_txid, None)?;
+                            if spending_tx.input.iter().any(|txi| self.tracker.get_blockhash_by_txid(txi.previous_output.txid).is_none()) {
+                                if funding_inputs_confirmed {
+                                    return Ok(json!({"height": funding_height, "spender_txhash": spender_txid, "spender_height": -1}));
+                                }
+                                return Ok(json!({"height": -1, "spender_txhash": spender_txid, "spender_height": -1}));
+                            } else {return Ok(json!({"height": funding_height, "spender_txhash": spender_txid, "spender_height": 0}));}
+                        }
+                }
+            },
+            None => return Ok(json!({"height": funding_height})),
+        };
+    }
+
     fn transaction_broadcast(&self, (tx_hex,): (String,)) -> Result<Value> {
         let tx_bytes = Vec::from_hex(&tx_hex).context("non-hex transaction")?;
         let tx = deserialize(&tx_bytes).context("invalid transaction")?;
@@ -384,6 +449,7 @@ impl Rpc {
                 Call::Donation => Ok(Value::Null),
                 Call::EstimateFee(args) => self.estimate_fee(args),
                 Call::HeadersSubscribe => self.headers_subscribe(client),
+                Call::OutpointSubscribe(args) => self.outpoint_subscribe(args),
                 Call::MempoolFeeHistogram => self.get_fee_histogram(),
                 Call::PeersSubscribe => Ok(json!([])),
                 Call::Ping => Ok(Value::Null),
@@ -423,6 +489,7 @@ enum Call {
     EstimateFee((u16,)),
     HeadersSubscribe,
     MempoolFeeHistogram,
+    OutpointSubscribe((Txid, u32)),
     PeersSubscribe,
     Ping,
     RelayFee,
@@ -441,6 +508,7 @@ impl Call {
             "blockchain.block.headers" => Call::BlockHeaders(convert(params)?),
             "blockchain.estimatefee" => Call::EstimateFee(convert(params)?),
             "blockchain.headers.subscribe" => Call::HeadersSubscribe,
+            "blockchain.outpoint.subscribe" => Call::OutpointSubscribe(convert(params)?),
             "blockchain.relayfee" => Call::RelayFee,
             "blockchain.scripthash.get_balance" => Call::ScriptHashGetBalance(convert(params)?),
             "blockchain.scripthash.get_history" => Call::ScriptHashGetHistory(convert(params)?),
@@ -484,3 +552,8 @@ fn result_msg(id: Value, result: Value) -> Value {
 fn error_msg(id: Value, error: RpcError) -> Value {
     json!({"jsonrpc": "2.0", "id": id, "error": error.to_value()})
 }
+
+fn is_spending(tx: &Transaction, funding: OutPoint) -> bool {
+    tx.input.iter().any(|txi| txi.previous_output == funding)
+}
+

src/tracker.rs

@@ -44,6 +44,10 @@ impl Tracker {
         self.index.chain()
     }
 
+    pub(crate) fn mempool(&self) -> &Mempool {
+        &self.mempool
+    }
+
     pub(crate) fn fees_histogram(&self) -> &Histogram {
         self.mempool.fees_histogram()
     }