2025 implement bip352 receiving

src/interfaces/chain.h

@@ -61,6 +61,8 @@ class FoundBlock
     //! Read block data from disk. If the block exists but doesn't have data
     //! (for example due to pruning), the CBlock variable will be set to null.
     FoundBlock& data(CBlock& data) { m_data = &data; return *this; }
+    //! Read block's undo data from disk.
+    FoundBlock& undoData(CBlockUndo& undo) { m_undo = &undo; return *this; }
 
     uint256* m_hash = nullptr;
     int* m_height = nullptr;
@@ -71,6 +73,7 @@ class FoundBlock
     CBlockLocator* m_locator = nullptr;
     const FoundBlock* m_next_block = nullptr;
     CBlock* m_data = nullptr;
+    CBlockUndo* m_undo = nullptr;
     mutable bool found = false;
 };
 
@@ -318,7 +321,7 @@ class Chain
     {
     public:
         virtual ~Notifications() = default;
-        virtual void transactionAddedToMempool(const CTransactionRef& tx) {}
+        virtual void transactionAddedToMempool(const CTransactionRef& tx, const std::map<COutPoint, Coin>& spent_coins) {}
         virtual void transactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason) {}
         virtual void blockConnected(ChainstateRole role, const BlockInfo& block) {}
         virtual void blockDisconnected(const BlockInfo& block) {}

src/key.cpp

@@ -166,6 +166,13 @@ void CKey::MakeNewKey(bool fCompressedIn) {
     fCompressed = fCompressedIn;
 }
 
+bool CKey::TweakAdd(const unsigned char *tweak32)
+{
+    assert(keydata);
+    // Modify the current CKey's data directly.
+    return secp256k1_ec_seckey_tweak_add(secp256k1_context_sign, keydata->data(), tweak32);
+}
+
 CPrivKey CKey::GetPrivKey() const {
     assert(keydata);
     CPrivKey seckey;

src/key.h

@@ -128,6 +128,8 @@ class CKey
     //! Generate a new private key using a cryptographic PRNG.
     void MakeNewKey(bool fCompressed);
 
+    bool TweakAdd(const unsigned char *tweak32);
+
     /**
      * Convert the private key to a CPrivKey (serialized OpenSSL private key data).
      * This is expensive.

src/node/interfaces.cpp

@@ -53,6 +53,7 @@
 #include <sync.h>
 #include <txmempool.h>
 #include <uint256.h>
+#include <undo.h>
 #include <univalue.h>
 #include <util/check.h>
 #include <util/result.h>
@@ -446,6 +447,10 @@ bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<Rec
         REVERSE_LOCK(lock);
         if (!blockman.ReadBlock(*block.m_data, *index)) block.m_data->SetNull();
     }
+    if (block.m_undo) {
+        REVERSE_LOCK(lock);
+        if (!blockman.ReadBlockUndo(*block.m_undo, *index)) block.m_undo->vtxundo.clear();
+    }
     block.found = true;
     return true;
 }
@@ -456,9 +461,9 @@ class NotificationsProxy : public CValidationInterface
     explicit NotificationsProxy(std::shared_ptr<Chain::Notifications> notifications)
         : m_notifications(std::move(notifications)) {}
     virtual ~NotificationsProxy() = default;
-    void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence) override
+    void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence, const std::map<COutPoint, Coin>& spent_coins) override
     {
-        m_notifications->transactionAddedToMempool(tx.info.m_tx);
+        m_notifications->transactionAddedToMempool(tx.info.m_tx, spent_coins);
     }
     void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override
     {
@@ -860,7 +865,12 @@ class ChainImpl : public Chain
         if (!m_node.mempool) return;
         LOCK2(::cs_main, m_node.mempool->cs);
         for (const CTxMemPoolEntry& entry : m_node.mempool->entryAll()) {
-            notifications.transactionAddedToMempool(entry.GetSharedTx());
+            std::map<COutPoint, Coin> spent_coins;
+            for (const CTxIn& txin : entry.GetTx().vin) {
+                spent_coins[txin.prevout];
+            }
+            findCoins(spent_coins);
+            notifications.transactionAddedToMempool(entry.GetSharedTx(), spent_coins);
         }
     }
     bool hasAssumedValidChain() override

src/outputtype.cpp

@@ -19,6 +19,7 @@ static const std::string OUTPUT_TYPE_STRING_LEGACY = "legacy";
 static const std::string OUTPUT_TYPE_STRING_P2SH_SEGWIT = "p2sh-segwit";
 static const std::string OUTPUT_TYPE_STRING_BECH32 = "bech32";
 static const std::string OUTPUT_TYPE_STRING_BECH32M = "bech32m";
+static const std::string OUTPUT_TYPE_STRING_SILENT_PAYMENTS = "silent-payments";
 static const std::string OUTPUT_TYPE_STRING_UNKNOWN = "unknown";
 
 std::optional<OutputType> ParseOutputType(const std::string& type)
@@ -31,6 +32,8 @@ std::optional<OutputType> ParseOutputType(const std::string& type)
         return OutputType::BECH32;
     } else if (type == OUTPUT_TYPE_STRING_BECH32M) {
         return OutputType::BECH32M;
+    } else if (type == OUTPUT_TYPE_STRING_SILENT_PAYMENTS) {
+        return OutputType::SILENT_PAYMENTS;
     }
     return std::nullopt;
 }
@@ -42,6 +45,7 @@ const std::string& FormatOutputType(OutputType type)
     case OutputType::P2SH_SEGWIT: return OUTPUT_TYPE_STRING_P2SH_SEGWIT;
     case OutputType::BECH32: return OUTPUT_TYPE_STRING_BECH32;
     case OutputType::BECH32M: return OUTPUT_TYPE_STRING_BECH32M;
+    case OutputType::SILENT_PAYMENTS: return OUTPUT_TYPE_STRING_SILENT_PAYMENTS;
     case OutputType::UNKNOWN: return OUTPUT_TYPE_STRING_UNKNOWN;
     } // no default case, so the compiler can warn about missing cases
     assert(false);
@@ -63,6 +67,7 @@ CTxDestination GetDestinationForKey(const CPubKey& key, OutputType type)
         }
     }
     case OutputType::BECH32M:
+    case OutputType::SILENT_PAYMENTS:
     case OutputType::UNKNOWN: {} // This function should never be used with BECH32M or UNKNOWN, so let it assert
     } // no default case, so the compiler can warn about missing cases
     assert(false);
@@ -102,6 +107,7 @@ CTxDestination AddAndGetDestinationForScript(FlatSigningProvider& keystore, cons
         }
     }
     case OutputType::BECH32M:
+    case OutputType::SILENT_PAYMENTS:
     case OutputType::UNKNOWN: {} // This function should not be used for BECH32M or UNKNOWN, so let it assert
     } // no default case, so the compiler can warn about missing cases
     assert(false);

src/outputtype.h

@@ -19,6 +19,7 @@ enum class OutputType {
     P2SH_SEGWIT,
     BECH32,
     BECH32M,
+    SILENT_PAYMENTS,
     UNKNOWN,
 };
 
@@ -27,6 +28,7 @@ static constexpr auto OUTPUT_TYPES = std::array{
     OutputType::P2SH_SEGWIT,
     OutputType::BECH32,
     OutputType::BECH32M,
+    OutputType::SILENT_PAYMENTS,
 };
 
 std::optional<OutputType> ParseOutputType(const std::string& str);

src/policy/fees.cpp

@@ -577,7 +577,7 @@ CBlockPolicyEstimator::CBlockPolicyEstimator(const fs::path& estimation_filepath
 
 CBlockPolicyEstimator::~CBlockPolicyEstimator() = default;
 
-void CBlockPolicyEstimator::TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t /*unused*/)
+void CBlockPolicyEstimator::TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t /*unused*/,  const std::map<COutPoint, Coin>& /*unused*/)
 {
     processTransaction(tx);
 }

src/policy/fees.h

@@ -264,7 +264,7 @@ class CBlockPolicyEstimator : public CValidationInterface
 
 protected:
     /** Overridden from CValidationInterface. */
-    void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t /*unused*/) override
+    void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t /*unused*/,  const std::map<COutPoint, Coin>& /*unused*/) override
         EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator);
     void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason /*unused*/, uint64_t /*unused*/) override
         EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator);

src/pubkey.cpp

@@ -273,6 +273,23 @@ std::optional<std::pair<XOnlyPubKey, bool>> XOnlyPubKey::CreateTapTweak(const ui
     return ret;
 }
 
+bool CPubKey::TweakAdd(const unsigned char *tweak32)
+{
+    secp256k1_pubkey original_pubkey;
+    int return_val = secp256k1_ec_pubkey_parse(secp256k1_context_static, &original_pubkey, data(), size());
+    assert(return_val);
+
+    return_val = secp256k1_ec_pubkey_tweak_add(secp256k1_context_static, &original_pubkey, tweak32);
+    assert(return_val);
+
+    unsigned char pubkey_bytes[COMPRESSED_SIZE];
+    size_t publen = COMPRESSED_SIZE;
+    return_val = secp256k1_ec_pubkey_serialize(secp256k1_context_static, pubkey_bytes, &publen, &original_pubkey, SECP256K1_EC_COMPRESSED);
+    assert(return_val);
+
+    Set(pubkey_bytes, pubkey_bytes + publen);
+    return IsValid();
+}
 
 bool CPubKey::Verify(const uint256 &hash, const std::vector<unsigned char>& vchSig) const {
     if (!IsValid())

src/pubkey.h

@@ -211,6 +211,7 @@ class CPubKey
      * If this public key is not fully valid, the return value will be false.
      */
     bool Verify(const uint256& hash, const std::vector<unsigned char>& vchSig) const;
+    bool TweakAdd(const unsigned char *tweak32);
 
     /**
      * Check whether a signature is normalized (lower-S).

src/rpc/client.cpp

@@ -300,6 +300,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "createwallet", 5, "descriptors"},
     { "createwallet", 6, "load_on_startup"},
     { "createwallet", 7, "external_signer"},
+    { "createwallet", 8, "silent_payments" },
     { "restorewallet", 2, "load_on_startup"},
     { "loadwallet", 1, "load_on_startup"},
     { "unloadwallet", 1, "load_on_startup"},

src/rpc/util.cpp

@@ -301,7 +301,9 @@ class DescribeAddressVisitor
 
     UniValue operator()(const V0SilentPaymentDestination& dest) const
     {
-        return UniValue(UniValue::VOBJ);
+        UniValue obj(UniValue::VOBJ);
+        obj.pushKV("iswitness", false);
+        return obj;
     }
 
     UniValue operator()(const PubKeyDestination& dest) const