wallet/tests: Enable Silent Payments in wallet unit tests

Author: Eunovo

src/wallet/test/util.cpp

@@ -27,6 +27,7 @@ std::unique_ptr<CWallet> CreateSyncedWallet(interfaces::Chain& chain, CChain& cc
     {
         LOCK(wallet->cs_wallet);
         wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
+        wallet->SetWalletFlag(WALLET_FLAG_SILENT_PAYMENTS);
         wallet->SetupDescriptorScriptPubKeyMans();
 
         FlatSigningProvider provider;

src/wallet/test/wallet_tests.cpp

@@ -376,6 +376,9 @@ class ListCoinsTestingSetup : public TestChain100Setup
     {
         CTransactionRef tx;
         CCoinControl dummy;
+        if (std::holds_alternative<V0SilentPaymentDestination>(recipient.dest)) {
+            dummy.m_silent_payment = true;
+        }
         {
             auto res = CreateTransaction(*wallet, {recipient}, /*change_pos=*/std::nullopt, dummy);
             BOOST_CHECK(res);
@@ -492,10 +495,28 @@ BOOST_FIXTURE_TEST_CASE(BasicOutputTypesTest, ListCoinsTest)
     //   2. One UTXO from the change, due to payment address matching logic
 
     for (const auto& out_type : OUTPUT_TYPES) {
-        if (out_type == OutputType::UNKNOWN || out_type == OutputType::SILENT_PAYMENTS) continue;
+        if (out_type == OutputType::UNKNOWN) continue;
+        if (out_type == OutputType::SILENT_PAYMENTS) continue;
         expected_coins_sizes[out_type] = 2U;
         TestCoinsResult(*this, out_type, 1 * COIN, expected_coins_sizes);
     }
+
+    // Add a taproot UTXO to be used for creating a silent payment
+    util::Result<CTxDestination> dest = Assert(wallet->GetNewDestination(OutputType::BECH32M, ""));
+    AddTx(CRecipient{*dest, 1 * COIN, /*fSubtractFeeFromAmount=*/true});
+    CoinFilterParams filter;
+    filter.skip_locked = true;
+    available_coins = WITH_LOCK(wallet->cs_wallet, return AvailableCoins(*wallet, nullptr, std::nullopt, filter));
+    BOOST_CHECK_EQUAL(available_coins.coins[OutputType::BECH32M].size(), 2U);
+    // Expect 4 OutputType::BECH32M UTXOs
+    // 1. One UTXO as the recipient because Silent Payments produce taproot scriptPubKeys
+    // 3. Two locked UTXOs from previous OutputType::BECH32M test
+    expected_coins_sizes[OutputType::BECH32M] = 3U;
+    // Expect 2 OutputType::BECH32M UTXOs
+    // 1. One UTXO from mining the previous block
+    // 1. One UTXO from mining the block used in the test
+    expected_coins_sizes[OutputType::UNKNOWN] = 2U;
+    TestCoinsResult(*this, OutputType::SILENT_PAYMENTS, 1 * COIN, expected_coins_sizes);
 }
 
 BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup)

src/wallet/wallet.cpp

@@ -1643,7 +1643,7 @@ bool CWallet::IsMine(const CTransaction& tx, const std::map<COutPoint, Coin>& sp
     AssertLockHeld(cs_wallet);
 
     // Scan for silent payments first
-    if (IsWalletFlagSet(WALLET_FLAG_SILENT_PAYMENTS) && !tx.IsCoinBase()) {
+    if (IsWalletFlagSet(WALLET_FLAG_SILENT_PAYMENTS) && !tx.IsCoinBase() && !spent_coins.empty()) {
         auto sp_data = GetSilentPaymentsData(tx, spent_coins);
         if (sp_data.has_value()) {
             bool found{false};

test/functional/wallet_silentpayments_receiving.py

@@ -211,6 +211,34 @@ def test_rbf(self):
         self.generate(self.nodes[0], 1)
         assert_approx(wallet.getbalance(), 49.99, 0.0001)
 
+    def test_conflict(self):
+        self.log.info("Check Silent Payments wallet handles conflicts")
+
+        self.nodes[0].createwallet(wallet_name="conflict", silent_payments=True)
+        wallet = self.nodes[0].get_wallet_rpc("conflict")
+        address = wallet.getnewaddress(address_type="bech32m")
+        unspents = self.def_wallet.listunspent()
+        # walletcreatefundedpsbt fails when receipients include silent-payment addresses
+        # use bech32m instead
+        psbt = self.def_wallet.walletcreatefundedpsbt(inputs=[unspents[0]], outputs=[{address : 49.99}])["psbt"]
+        tx1 = self.def_wallet.walletprocesspsbt(psbt=psbt, finalize=True)['hex']
+
+        # Create tx2 to spend the same input as tx1
+        psbt = self.def_wallet.walletcreatefundedpsbt(inputs=[unspents[0]], outputs=[{self.def_wallet.getnewaddress() : 49.99}])["psbt"]
+        tx2 =  self.def_wallet.walletprocesspsbt(psbt=psbt, finalize=True)['hex']
+
+        self.nodes[0].sendrawtransaction(tx1)
+
+        # Mine conflicting transaction on node 1
+        self.disconnect_nodes(0, 1)
+        self.nodes[1].sendrawtransaction(tx2)
+        self.generate(self.nodes[1], 1, sync_fun=self.no_op)
+
+        self.connect_nodes(0, 1)
+        self.sync_blocks()
+
+        assert_equal(wallet.getbalance(), 0)
+
     def test_createwallet_descriptor(self):
         self.log.info("Check createwalletdescriptor works with silent payments descriptor")
 
@@ -277,6 +305,7 @@ def run_test(self):
         self.test_import_rescan()
         self.test_createwallet_descriptor()
         self.test_getaddressinfo()
+        self.test_conflict()