Add the silent payment index

Co-Authored-By: w0xlt <[email protected]>

Co-Authored-By: furszy <[email protected]>

Author: Sjors

src/CMakeLists.txt

@@ -237,6 +237,7 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL
   httpserver.cpp
   i2p.cpp
   index/base.cpp
+  index/bip352.cpp
   index/blockfilterindex.cpp
   index/coinstatsindex.cpp
   index/txindex.cpp
@@ -325,6 +326,7 @@ target_link_libraries(bitcoin_node
     $<TARGET_NAME_IF_EXISTS:bitcoin_zmq>
     leveldb
     minisketch
+    secp256k1
     univalue
     Boost::headers
     $<TARGET_NAME_IF_EXISTS:libevent::core>

src/index/bip352.cpp

@@ -0,0 +1,109 @@
+// Copyright (c) 2023-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <index/bip352.h>
+
+#include <common/bip352.h>
+#include <chainparams.h>
+#include <coins.h>
+#include <common/args.h>
+#include <index/disktxpos.h>
+#include <node/blockstorage.h>
+#include <pubkey.h>
+#include <primitives/transaction.h>
+
+#include <undo.h>
+#include <validation.h>
+
+#include <dbwrapper.h>
+#include <hash.h>
+
+constexpr uint8_t DB_SILENT_PAYMENT_INDEX{'s'};
+/* Save space on mainnet by starting the index at Taproot activation.
+ * Copying the height here assuming DEPLOYMENT_TAPROOT will be dropped:
+ * https://github.com/bitcoin/bitcoin/pull/26201/
+ * Only apply this storage optimization on mainnet.
+ */
+const int TAPROOT_MAINNET_ACTIVATION_HEIGHT{709632};
+
+std::unique_ptr<BIP352Index> g_bip352_index;
+
+/** Access to the silent payment index database (indexes/bip352/) */
+class BIP352Index::DB : public BaseIndex::DB
+{
+public:
+    explicit DB(size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
+
+    bool WriteSilentPayments(const std::pair<uint256, std::vector<CPubKey>>& tweaks);
+};
+
+BIP352Index::DB::DB(size_t n_cache_size, bool f_memory, bool f_wipe) :
+    BaseIndex::DB(gArgs.GetDataDirNet() / "indexes" / "bip352", n_cache_size, f_memory, f_wipe)
+{}
+
+bool BIP352Index::DB::WriteSilentPayments(const std::pair<uint256, std::vector<CPubKey>>& tweaks)
+{
+    CDBBatch batch(*this);
+    batch.Write(std::make_pair(DB_SILENT_PAYMENT_INDEX, tweaks.first), tweaks.second);
+    return WriteBatch(batch);
+}
+
+BIP352Index::BIP352Index(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe)
+    : BaseIndex(std::move(chain), "bip352 index", /*start_height=*/Params().IsTestChain() ? 0 : TAPROOT_MAINNET_ACTIVATION_HEIGHT), m_db(std::make_unique<BIP352Index::DB>(n_cache_size, f_memory, f_wipe))
+{}
+
+BIP352Index::~BIP352Index() = default;
+
+bool BIP352Index::GetSilentPaymentKeys(const std::vector<CTransactionRef>& txs, const CBlockUndo& block_undo, std::vector<CPubKey>& tweaked_pub_key_sums) const
+{
+    assert(txs.size() - 1 == block_undo.vtxundo.size());
+
+    for (size_t i=0; i < txs.size(); i++) {
+        auto& tx = txs.at(i);
+
+        if (!bip352::MaybeSilentPayment(tx)) continue;
+
+        // -1 as blockundo does not have coinbase tx
+        CTxUndo undoTX{block_undo.vtxundo.at(i - 1)};
+        std::map<COutPoint, Coin> coins;
+
+        for (size_t j = 0; j < tx->vin.size(); j++) {
+            coins[tx->vin.at(j).prevout] = undoTX.vprevout.at(j);
+        }
+
+        std::optional<CPubKey> tweaked_pk = bip352::GetSerializedSilentPaymentsPublicData(tx->vin, coins);
+        if (tweaked_pk) tweaked_pub_key_sums.push_back(tweaked_pk.value());
+    }
+
+    return true;
+}
+
+interfaces::Chain::NotifyOptions BIP352Index::CustomOptions()
+{
+    interfaces::Chain::NotifyOptions options;
+    options.connect_undo_data = true;
+    return options;
+}
+
+bool BIP352Index::CustomAppend(const interfaces::BlockInfo& block)
+{
+    // Exclude genesis block transaction because outputs are not spendable. This
+    // is needed on non-mainnet chains because m_start_height is 0 by default.
+    if (block.height == 0) return true;
+
+    // Exclude pre-taproot
+    if (block.height < m_start_height) return true;
+
+    std::vector<CPubKey> tweaked_pub_key_sums;
+    GetSilentPaymentKeys(Assert(block.data)->vtx, *Assert(block.undo_data), tweaked_pub_key_sums);
+
+    return m_db->WriteSilentPayments(make_pair(block.hash, tweaked_pub_key_sums));
+}
+
+bool BIP352Index::FindSilentPayment(const uint256& block_hash, std::vector<CPubKey>& tweaked_pub_key_sums) const
+{
+    return m_db->Read(std::make_pair(DB_SILENT_PAYMENT_INDEX, block_hash), tweaked_pub_key_sums);
+}
+
+BaseIndex::DB& BIP352Index::GetDB() const { return *m_db; }

src/index/bip352.h

@@ -0,0 +1,63 @@
+// Copyright (c) 2023-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INDEX_BIP352_H
+#define BITCOIN_INDEX_BIP352_H
+
+#include <coins.h>
+#include <index/base.h>
+#include <pubkey.h>
+
+class COutPoint;
+class CBlockUndo;
+
+static constexpr bool DEFAULT_BIP352_INDEX{false};
+
+/**
+ * This index is used to look up the tweaked sum of eligible public keys for a
+ * given transaction hash. See BIP352.
+ *
+ * Currently only silent payments v0 exists. Future versions may expand the
+ * existing index or create a (perhaps overlapping) new one.
+ */
+class BIP352Index final : public BaseIndex
+{
+protected:
+    class DB;
+
+private:
+    const std::unique_ptr<DB> m_db;
+
+    bool AllowPrune() const override { return false; }
+
+    /**
+     * Derive the silent payment tweaked public key for every block transaction.
+     *
+     * @param[in] txs all block transactions
+     * @param[in] block_undo block undo data
+     * @param[out] tweaked_pub_key_sums the tweaked public keys, only for transactions that have one
+     * @return false if something went wrong
+     */
+    bool GetSilentPaymentKeys(const std::vector<CTransactionRef>& txs, const CBlockUndo& block_undo, std::vector<CPubKey>& tweaked_pub_key_sums) const;
+
+protected:
+    interfaces::Chain::NotifyOptions CustomOptions() override;
+
+    bool CustomAppend(const interfaces::BlockInfo& block) override;
+
+    BaseIndex::DB& GetDB() const override;
+public:
+
+    explicit BIP352Index(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
+
+    // Destructor is declared because this class contains a unique_ptr to an incomplete type.
+    virtual ~BIP352Index() override;
+
+    bool FindSilentPayment(const uint256& block_hash, std::vector<CPubKey>& tweaked_pub_key_sums) const;
+};
+
+/// The global BIP325 index. May be null.
+extern std::unique_ptr<BIP352Index> g_bip352_index;
+
+#endif // BITCOIN_INDEX_BIP352_H

src/init.cpp

@@ -27,6 +27,7 @@
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <index/txindex.h>
+#include <index/bip352.h>
 #include <init/common.h>
 #include <interfaces/chain.h>
 #include <interfaces/init.h>
@@ -352,6 +353,7 @@ void Shutdown(NodeContext& node)
     for (auto* index : node.indexes) index->Stop();
     if (g_txindex) g_txindex.reset();
     if (g_coin_stats_index) g_coin_stats_index.reset();
+    if (g_bip352_index) g_bip352_index.reset();
     DestroyAllBlockFilterIndexes();
     node.indexes.clear(); // all instances are nullptr now
 
@@ -512,6 +514,9 @@ void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
     argsman.AddArg("-shutdownnotify=<cmd>", "Execute command immediately before beginning shutdown. The need for shutdown may be urgent, so be careful not to delay it long (if the command doesn't require interaction with the server, consider having it fork into the background).", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #endif
     argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    argsman.AddArg("-bip352index",
+                 strprintf("Maintain an index of BIP352 v0 tweaked public keys. (default: %s)", DEFAULT_BIP352_INDEX),
+                 ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-blockfilterindex=<type>",
                  strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
                  " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
@@ -960,6 +965,8 @@ bool AppInitParameterInteraction(const ArgsManager& args)
     if (args.GetIntArg("-prune", 0)) {
         if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
             return InitError(_("Prune mode is incompatible with -txindex."));
+        if (args.GetBoolArg("-bip352index", DEFAULT_BIP352_INDEX))
+            return InitError(_("Prune mode is incompatible with -bip352index."));
         if (args.GetBoolArg("-reindex-chainstate", false)) {
             return InitError(_("Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
         }
@@ -1707,6 +1714,9 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         LogInfo("* Using %.1f MiB for transaction index database", index_cache_sizes.tx_index * (1.0 / 1024 / 1024));
     }
+    if (args.GetBoolArg("-bip352index", DEFAULT_BIP352_INDEX)) {
+        LogPrintf("* Using %.1f MiB for BIP352 index database\n", index_cache_sizes.bip352_index * (1.0 / 1024 / 1024));
+    }
     for (BlockFilterType filter_type : g_enabled_filter_types) {
         LogInfo("* Using %.1f MiB for %s block filter index database",
                   index_cache_sizes.filter_index * (1.0 / 1024 / 1024), BlockFilterTypeName(filter_type));
@@ -1783,6 +1793,11 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         node.indexes.emplace_back(g_coin_stats_index.get());
     }
 
+    if (args.GetBoolArg("-bip352index", DEFAULT_BIP352_INDEX)) {
+        g_bip352_index = std::make_unique<BIP352Index>(interfaces::MakeChain(node), index_cache_sizes.bip352_index, false, do_reindex);
+        node.indexes.emplace_back(g_bip352_index.get());
+    }
+
     // Init indexes
     for (auto index : node.indexes) if (!index->Init()) return false;
 

src/node/caches.cpp

@@ -5,6 +5,7 @@
 #include <node/caches.h>
 
 #include <common/args.h>
+#include <index/bip352.h>
 #include <index/txindex.h>
 #include <kernel/caches.h>
 #include <logging.h>
@@ -21,6 +22,8 @@ static constexpr size_t MAX_TX_INDEX_CACHE{1024_MiB};
 static constexpr size_t MAX_FILTER_INDEX_CACHE{1024_MiB};
 //! Maximum dbcache size on 32-bit systems.
 static constexpr size_t MAX_32BIT_DBCACHE{1024_MiB};
+//! Max memory allocated to the BIP352 index cache in bytes.
+static constexpr size_t MAX_BIP352_INDEX_CACHE{1024_MiB};
 
 namespace node {
 CacheSizes CalculateCacheSizes(const ArgsManager& args, size_t n_indexes)
@@ -36,12 +39,14 @@ CacheSizes CalculateCacheSizes(const ArgsManager& args, size_t n_indexes)
 
     IndexCacheSizes index_sizes;
     index_sizes.tx_index = std::min(total_cache / 8, args.GetBoolArg("-txindex", DEFAULT_TXINDEX) ? MAX_TX_INDEX_CACHE : 0);
+    index_sizes.bip352_index = std::min(total_cache / 8, args.GetBoolArg("-bip352index", DEFAULT_BIP352_INDEX) ? MAX_BIP352_INDEX_CACHE : 0);
     total_cache -= index_sizes.tx_index;
     if (n_indexes > 0) {
         size_t max_cache = std::min(total_cache / 8, MAX_FILTER_INDEX_CACHE);
         index_sizes.filter_index = max_cache / n_indexes;
         total_cache -= index_sizes.filter_index * n_indexes;
     }
+
     return {index_sizes, kernel::CacheSizes{total_cache}};
 }
 } // namespace node

src/node/caches.h

@@ -19,6 +19,7 @@ static constexpr size_t DEFAULT_DB_CACHE{DEFAULT_KERNEL_CACHE};
 
 namespace node {
 struct IndexCacheSizes {
+    size_t bip352_index{0};
     size_t tx_index{0};
     size_t filter_index{0};
 };

src/rpc/node.cpp

@@ -10,6 +10,7 @@
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <index/txindex.h>
+#include <index/bip352.h>
 #include <interfaces/chain.h>
 #include <interfaces/echo.h>
 #include <interfaces/init.h>
@@ -395,6 +396,11 @@ static RPCHelpMan getindexinfo()
         result.pushKVs(SummaryToJSON(g_coin_stats_index->GetSummary(), index_name));
     }
 
+    if (g_bip352_index) {
+        result.pushKVs(SummaryToJSON(g_bip352_index->GetSummary(), index_name));
+    }
+
+
     ForEachBlockFilterIndex([&result, &index_name](const BlockFilterIndex& index) {
         result.pushKVs(SummaryToJSON(index.GetSummary(), index_name));
     });