wip,test: Add test_spend_non_canonical_txout

Author: ValuedMammal

wallet/src/test_utils.rs

@@ -318,7 +318,7 @@ pub fn insert_checkpoint(wallet: &mut Wallet, block: BlockId) {
 }
 
 /// Inserts a transaction with anchor (no last seen). This is useful for adding
-/// a coinbase tx to a wallet for testing.
+/// a coinbase tx to the wallet for testing.
 ///
 /// This will also insert the anchor `block_id`. See [`insert_anchor`] for more.
 pub fn insert_tx_anchor(wallet: &mut Wallet, tx: Transaction, block_id: BlockId) {

wallet/src/wallet/mod.rs

@@ -1207,14 +1207,18 @@ impl Wallet {
     /// To iterate over all canonical transactions, including those that are irrelevant, use
     /// [`TxGraph::list_canonical_txs`].
     pub fn transactions<'a>(&'a self) -> impl Iterator<Item = WalletTx<'a>> + 'a {
+        self.transactions_with_params(CanonicalizationParams::default())
+    }
+
+    /// Transactions with params.
+    pub fn transactions_with_params<'a>(
+        &'a self,
+        params: CanonicalizationParams,
+    ) -> impl Iterator<Item = WalletTx<'a>> + 'a {
         let tx_graph = self.indexed_graph.graph();
         let tx_index = &self.indexed_graph.index;
         tx_graph
-            .list_canonical_txs(
-                &self.chain,
-                self.chain.tip().block_id(),
-                CanonicalizationParams::default(),
-            )
+            .list_canonical_txs(&self.chain, self.chain.tip().block_id(), params)
             .filter(|c_tx| tx_index.is_tx_relevant(&c_tx.tx_node.tx))
     }
 
@@ -2482,6 +2486,30 @@ impl Wallet {
         Ok(())
     }
 
+    /// Inserts a transaction into the inner transaction graph with no additional metadata.
+    ///
+    /// This is used to inform the wallet of newly created txs before they are known to exist
+    /// on chain (or in mempool), which is useful for discovering wallet-owned outputs of
+    /// not-yet-canonical transactions.
+    ///
+    /// The effect of insertion depends on the [relevance] of `tx` as determined by the indexer.
+    /// If the transaction was newly inserted and a txout matches a derived SPK, then the index
+    /// is updated with the relevant outpoint. This means the output may be selected in
+    /// subsequent transactions (if selected manually), enabling chains of dependent spends to
+    /// occur prior to broadcast time. If none of the outputs are relevant, the transaction is
+    /// kept but the index remains unchanged. If the transaction was already present in-graph,
+    /// the effect is a no-op.
+    ///
+    /// **You must persist the change set staged as a result of this call.**
+    ///
+    /// [relevance]: Indexer::is_tx_relevant
+    pub fn insert_tx<T>(&mut self, tx: T)
+    where
+        T: Into<Arc<Transaction>>,
+    {
+        self.stage.merge(self.indexed_graph.insert_tx(tx).into());
+    }
+
     /// Apply relevant unconfirmed transactions to the wallet.
     ///
     /// Transactions that are not relevant are filtered out.
@@ -2746,8 +2774,12 @@ impl Wallet {
         });
 
         // Get wallet txouts.
+        let mut canon_params = params.canonical_params.clone();
+        canon_params
+            .assume_canonical
+            .extend(params.utxos.iter().map(|op| op.txid));
         let txouts = self
-            .list_indexed_txouts(params.canonical_params.clone())
+            .list_indexed_txouts(canon_params)
             .map(|(_, txo)| (txo.outpoint, txo))
             .collect();
 

wallet/tests/wallet.rs

@@ -6,7 +6,7 @@ use bdk_chain::{BlockId, CanonicalizationParams, ConfirmationBlockTime};
 use bdk_wallet::coin_selection;
 use bdk_wallet::descriptor::{calc_checksum, DescriptorError};
 use bdk_wallet::error::CreateTxError;
-use bdk_wallet::psbt::PsbtUtils;
+use bdk_wallet::psbt::{self, PsbtUtils};
 use bdk_wallet::signer::{SignOptions, SignerError};
 use bdk_wallet::test_utils::*;
 use bdk_wallet::KeychainKind;
@@ -25,6 +25,87 @@ use rand::SeedableRng;
 
 mod common;
 
+// Test we can select and spend an indexed but not-yet-canonical utxo
+#[test]
+fn test_spend_non_canonical_txout() -> anyhow::Result<()> {
+    let (desc, change_desc) = get_test_wpkh_and_change_desc();
+    let mut wallet = Wallet::create(desc, change_desc)
+        .network(Network::Regtest)
+        .create_wallet_no_persist()
+        .unwrap();
+
+    let recip = ScriptBuf::from_hex("0014446906a6560d8ad760db3156706e72e171f3a2aa").unwrap();
+
+    // Receive tx0 (coinbase)
+    let tx = Transaction {
+        input: vec![TxIn::default()],
+        output: vec![TxOut {
+            value: Amount::ONE_BTC,
+            script_pubkey: wallet
+                .reveal_next_address(KeychainKind::External)
+                .script_pubkey(),
+        }],
+        ..new_tx(1)
+    };
+    let block = BlockId {
+        height: 100,
+        hash: Hash::hash(b"100"),
+    };
+    insert_tx_anchor(&mut wallet, tx, block);
+    let block = BlockId {
+        height: 1000,
+        hash: Hash::hash(b"1000"),
+    };
+    insert_checkpoint(&mut wallet, block);
+
+    // Create tx1
+    let mut params = psbt::PsbtParams::default();
+    params.add_recipients([(recip.clone(), Amount::from_btc(0.01)?)]);
+    let psbt = wallet.create_psbt(params)?.0;
+    let txid = psbt.unsigned_tx.compute_txid();
+    let (vout, _) = psbt
+        .unsigned_tx
+        .output
+        .iter()
+        .enumerate()
+        .find(|(_, txo)| wallet.is_mine(txo.script_pubkey.clone()))
+        .unwrap();
+    let to_select_op = OutPoint::new(txid, vout as u32);
+
+    let txid1 = psbt.unsigned_tx.compute_txid();
+    wallet.insert_tx(psbt.unsigned_tx);
+
+    // Create tx2, spending the change of tx1
+    let mut params = psbt::PsbtParams::default();
+    params
+        .add_utxos(&[to_select_op])
+        .feerate(FeeRate::from_sat_per_vb_unchecked(10))
+        .add_recipients([(recip, Amount::from_btc(0.01)?)]);
+
+    let psbt = wallet.create_psbt(params)?.0;
+
+    assert_eq!(psbt.unsigned_tx.input.len(), 1);
+    assert_eq!(psbt.unsigned_tx.input[0].previous_output, to_select_op);
+
+    let txid2 = psbt.unsigned_tx.compute_txid();
+    wallet.insert_tx(psbt.unsigned_tx);
+
+    // Query the set of unbroadcasted txs
+    let txs = wallet
+        .transactions_with_params(CanonicalizationParams {
+            assume_canonical: vec![txid2],
+        })
+        .filter(|c| c.chain_position.is_unconfirmed())
+        .collect::<Vec<_>>();
+
+    assert_eq!(txs.len(), 2);
+
+    assert!(txs.iter().any(|c| c.tx_node.txid == txid1));
+    assert!(txs.iter().any(|c| c.tx_node.txid == txid2));
+
+    Ok(())
+}
+
 #[test]
 fn test_error_external_and_internal_are_the_same() {
     // identical descriptors should fail to create wallet