feat(chain): add method iter_spks_with_expected_txids

Author: ValuedMammal

crates/chain/src/indexed_tx_graph.rs

@@ -1,13 +1,16 @@
 //! Contains the [`IndexedTxGraph`] and associated types. Refer to the
 //! [`IndexedTxGraph`] documentation for more.
-use core::fmt::Debug;
+
+use core::fmt;
+use core::ops::RangeBounds;
 
 use alloc::{sync::Arc, vec::Vec};
-use bitcoin::{Block, OutPoint, Transaction, TxOut, Txid};
+use bitcoin::{Block, OutPoint, ScriptBuf, Transaction, TxOut, Txid};
 
 use crate::{
+    spk_txout::SpkTxOutIndex,
     tx_graph::{self, TxGraph},
-    Anchor, BlockId, Indexer, Merge, TxPosInBlock,
+    Anchor, BlockId, ChainOracle, Indexer, Merge, TxPosInBlock,
 };
 
 /// The [`IndexedTxGraph`] combines a [`TxGraph`] and an [`Indexer`] implementation.
@@ -324,6 +327,43 @@ where
             indexer,
         }
     }
+
+    /// Inserts the given `evicted_at` for `txid`.
+    ///
+    /// The `evicted_at` timestamp represents the last known time when the transaction was observed
+    /// to be missing from the mempool. If `txid` was previously recorded with an earlier
+    /// `evicted_at` value, it is updated only if the new value is greater.
+    pub fn insert_evicted_at(&mut self, txid: Txid, evicted_at: u64) -> ChangeSet<A, I::ChangeSet> {
+        let tx_graph = self.graph.insert_evicted_at(txid, evicted_at);
+        ChangeSet {
+            tx_graph,
+            ..Default::default()
+        }
+    }
+}
+
+impl<A, I> IndexedTxGraph<A, SpkTxOutIndex<I>>
+where
+    A: Anchor,
+    I: fmt::Debug + Clone + Ord,
+{
+    /// Returns an iterator over unconfirmed transactions and their associated script pubkeys,
+    /// filtered within the specified `range`.
+    ///
+    /// This function delegates the transaction filtering to [`TxGraph::iter_spks_with_expected_txids`],
+    /// using the [`SpkTxOutIndex`] stored in [`IndexedTxGraph`]. The [`TxGraph`] internally scans
+    /// for unconfirmed transactions relevant to the indexed outputs.
+    pub fn iter_spks_with_expected_txids<'a, O>(
+        &'a self,
+        chain: &'a O,
+        range: impl RangeBounds<I> + 'a,
+    ) -> impl Iterator<Item = (Txid, ScriptBuf)> + 'a
+    where
+        O: ChainOracle<Error = core::convert::Infallible>,
+    {
+        self.graph
+            .iter_spks_with_expected_txids(chain, &self.index, range)
+    }
 }
 
 impl<A, I> AsRef<TxGraph<A>> for IndexedTxGraph<A, I> {

crates/chain/src/tx_graph.rs

@@ -91,9 +91,11 @@
 //! [`insert_txout`]: TxGraph::insert_txout
 
 use crate::collections::*;
+use crate::spk_txout::SpkTxOutIndex;
 use crate::BlockId;
 use crate::CanonicalIter;
 use crate::CanonicalReason;
+use crate::Indexer;
 use crate::ObservedIn;
 use crate::{Anchor, Balance, ChainOracle, ChainPosition, FullTxOut, Merge};
 use alloc::collections::vec_deque::VecDeque;
@@ -105,7 +107,7 @@ use bitcoin::{Amount, OutPoint, ScriptBuf, SignedAmount, Transaction, TxOut, Txi
 use core::fmt::{self, Formatter};
 use core::{
     convert::Infallible,
-    ops::{Deref, RangeInclusive},
+    ops::{Deref, RangeBounds, RangeInclusive},
 };
 
 impl<A: Ord> From<TxGraph<A>> for TxUpdate<A> {
@@ -1161,6 +1163,50 @@ impl<A: Anchor> TxGraph<A> {
         self.try_balance(chain, chain_tip, outpoints, trust_predicate)
             .expect("oracle is infallible")
     }
+
+    /// Returns an iterator over unconfirmed transactions and their associated script pubkeys,
+    /// filtered within the specified `range`.
+    ///
+    /// This function scans the transaction graph for unconfirmed transactions relevant to the
+    /// provided [`SpkTxOutIndex`], determining which transactions should be considered based on
+    /// indexed outputs.
+    pub fn iter_spks_with_expected_txids<'a, C, I>(
+        &'a self,
+        chain: &'a C,
+        indexer: &'a SpkTxOutIndex<I>,
+        range: impl RangeBounds<I> + 'a,
+    ) -> impl Iterator<Item = (Txid, ScriptBuf)> + 'a
+    where
+        C: ChainOracle<Error = core::convert::Infallible>,
+        I: fmt::Debug + Clone + Ord,
+    {
+        let chain_tip = chain.get_chain_tip().unwrap();
+
+        self.list_canonical_txs(chain, chain_tip)
+            .filter(|c| !c.chain_position.is_confirmed() && indexer.is_tx_relevant(&c.tx_node))
+            .flat_map(move |c| {
+                let txid = c.tx_node.txid;
+                let spks = c
+                    .tx_node
+                    .input
+                    .iter()
+                    .map(|txin| txin.previous_output)
+                    .chain(
+                        c.tx_node
+                            .output
+                            .iter()
+                            .enumerate()
+                            .map(move |(vout, _)| OutPoint::new(txid, vout as u32)),
+                    )
+                    .flat_map(|op| match indexer.txout(op) {
+                        Some((i, txo)) if range.contains(i) => Some(txo.script_pubkey.clone()),
+                        _ => None,
+                    })
+                    .collect::<Vec<_>>();
+
+                core::iter::repeat(txid).zip(spks)
+            })
+    }
 }
 
 /// The [`ChangeSet`] represents changes to a [`TxGraph`].