WIP: Removed bdk_chain dependency

This now makes it more involved to interface this with `bdk_chain` and
`bdk_wallet`. Needs some more thought.

Author: evanlinjin

Cargo.toml

@@ -11,14 +11,14 @@ readme = "README.md"
 [dependencies]
 miniscript = { version = "12", default-features = false }
 bdk_coin_select = "0.4.0"
-bdk_chain = { version = "0.21" }
 
 [dev-dependencies]
 anyhow = "1"
 bdk_tx = { path = "." }
 bitcoin = { version = "0.32", features = ["rand-std"] }
 bdk_testenv = "0.11.1"
 bdk_bitcoind_rpc = "0.18.0"
+bdk_chain = { version = "0.21" }
 
 [features]
 default = ["std"]

src/canonical_leaves.rs

@@ -0,0 +1,103 @@
+use alloc::sync::Arc;
+
+use bitcoin::{psbt, OutPoint, Sequence, Transaction, Txid};
+use miniscript::{bitcoin, plan::Plan};
+
+use crate::{collections::HashMap, Input, InputStatus};
+
+/// Tx with confirmation status.
+pub type TxWithStatus<T> = (T, Option<InputStatus>);
+
+/// Our canonical view.
+#[derive(Debug, Clone)]
+pub struct CanonicalLeaves {
+    txs: HashMap<Txid, Arc<Transaction>>,
+    statuses: HashMap<Txid, InputStatus>,
+    spends: HashMap<OutPoint, Txid>,
+}
+
+impl CanonicalLeaves {
+    /// Construct.
+    pub fn new<T>(canonical_txs: impl IntoIterator<Item = TxWithStatus<T>>) -> Self
+    where
+        T: Into<Arc<Transaction>>,
+    {
+        let mut txs = HashMap::new();
+        let mut statuses = HashMap::new();
+        let mut spends = HashMap::new();
+        for (tx, status) in canonical_txs {
+            let tx: Arc<Transaction> = tx.into();
+            let txid = tx.compute_txid();
+            spends.extend(tx.input.iter().map(|txin| (txin.previous_output, txid)));
+            txs.insert(txid, tx);
+            if let Some(status) = status {
+                statuses.insert(txid, status);
+            }
+        }
+        Self {
+            txs,
+            statuses,
+            spends,
+        }
+    }
+
+    /// Whether outpoint is a leaf (unspent).
+    pub fn is_leaf(&self, outpoint: OutPoint) -> bool {
+        if self.spends.contains_key(&outpoint) {
+            return false;
+        }
+        match self.txs.get(&outpoint.txid) {
+            Some(tx) => {
+                let vout: usize = outpoint.vout.try_into().expect("vout must fit into usize");
+                vout < tx.output.len()
+            }
+            None => false,
+        }
+    }
+
+    /// Try get leaf (unspent) of given `outpoint`.
+    pub fn try_get_leaf(&self, outpoint: OutPoint, plan: Plan) -> Option<Input> {
+        if self.spends.contains_key(&outpoint) {
+            return None;
+        }
+        let prev_tx = Arc::clone(self.txs.get(&outpoint.txid)?);
+        Input::from_prev_tx(
+            plan,
+            prev_tx,
+            outpoint.vout.try_into().expect("vout must fit into usize"),
+            self.statuses.get(&outpoint.txid).cloned(),
+        )
+        .ok()
+    }
+
+    /// Try get leaves of given `outpoints`.
+    pub fn try_get_leaves<'a, O>(&'a self, outpoints: O) -> impl Iterator<Item = Input> + 'a
+    where
+        O: IntoIterator<Item = (OutPoint, Plan)>,
+        O::IntoIter: 'a,
+    {
+        outpoints
+            .into_iter()
+            .filter_map(|(op, plan)| self.try_get_leaf(op, plan))
+    }
+
+    /// Try get foreign leaf.
+    /// TODO: Check psbt_input data with our own prev tx data.
+    /// TODO: Create `try_get_foreign_leaves` method.
+    pub fn try_get_foreign_leaf(
+        &self,
+        outpoint: OutPoint,
+        sequence: Sequence,
+        psbt_input: psbt::Input,
+        satisfaction_weight: usize,
+    ) -> Option<Input> {
+        if self.spends.contains_key(&outpoint) {
+            return None;
+        }
+        let prev_tx = Arc::clone(self.txs.get(&outpoint.txid)?);
+        let output_index: usize = outpoint.vout.try_into().expect("vout must fit into usize");
+        let _txout = prev_tx.output.get(output_index)?;
+        let status = self.statuses.get(&outpoint.txid).cloned();
+        Input::from_psbt_input(outpoint, sequence, psbt_input, satisfaction_weight, status)
+    }
+}