Erlay: bandwidth-efficient transaction relay protocol #21515

 6+#define BITCOIN_TXRECONCILIATION_H
 7+
 8+#include <net.h>
 9+#include <sync.h>
10+
11+#include <tuple>

 7+
 8+#include <net.h>
 9+#include <sync.h>
10+
11+#include <tuple>
12+#include <unordered_map>

40+            we_initiate_recon = true;
41+            we_respond_recon = false;
42+        }
43+
44+        uint64_t m_local_recon_salt(GetRand(UINT64_MAX));
45+        WITH_LOCK(m_mutex, m_local_salts.emplace(peer_id, m_local_recon_salt));

51@@ -52,6 +52,14 @@ class TxReconciliationTracker::Impl {
52 
53         return std::make_tuple(we_initiate_recon, we_respond_recon, RECON_VERSION, m_local_recon_salt);
54     }
55+
56+    void RemovePeer(NodeId peer_id)
57+    {
58+        LOCK(m_mutex);
59+        m_local_salts.erase(peer_id);
60+        LogPrint(BCLog::NET, "Stop tracking reconciliation state for peer=%d.\n", peer_id);

121+        if (recon_state != m_states.end()) return;
122+
123+        recon_version = std::min(recon_version, RECON_VERSION);
124+        if (recon_version < 1) return;
125+
126+        // Must match SuggestReconciliation logic.

167+        LOCK(m_mutex);
168+        auto recon_state = m_states.find(peer_id);
169+        if (recon_state == m_states.end()) {
170+            return std::nullopt;
171+        }
172+        return (*recon_state).second.m_flood_to;

2546@@ -2539,6 +2547,28 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
2547                       pfrom.nVersion.load(), peer->m_starting_height,
2548                       pfrom.GetId(), (fLogIPs ? strprintf(", peeraddr=%s", pfrom.addr.ToString()) : ""),
2549                       pfrom.ConnectionTypeAsString());
2550+
2551+            // Keep track of the number of outbound flooding peers.
2552+            bool we_may_flood_to = false;
2553+            if (pfrom.MightSupportTransactionRelay()) {
2554+                if (m_reconciliation.IsPeerRegistered(pfrom.GetId())) {
2555+                    if (*m_reconciliation.IsPeerChosenForFlooding(pfrom.GetId())) {

4553@@ -4552,15 +4554,19 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
4554             }
4555             peer->m_blocks_for_inv_relay.clear();
4556 
4557+            const bool supports_recon = m_reconciliation.IsPeerRegistered(pto->GetId());

177@@ -154,6 +178,19 @@ class TxReconciliationTracker::Impl {
178             full_salt.GetUint64(1), we_initiate, flood_to));
179     }
180 
181+    void AddToReconSet(NodeId peer_id, const std::vector<uint256>& txs_to_reconcile)
182+    {
183+        LOCK(m_mutex);

185+        assert(recon_state != m_states.end());
186+        for (auto& wtxid: txs_to_reconcile) {
187+            recon_state->second.m_local_set.m_wtxids.insert(wtxid);
188+        }
189+
190+        LogPrint(BCLog::NET, "Added %i transactions to the reconciliation set for peer=%d.\n",

4628@@ -4622,6 +4629,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
4629                         // Fetch the top element from the heap
4630                         std::pop_heap(vInvTx.begin(), vInvTx.end(), compareInvMempoolOrder);
4631                         uint256 hash = vInvTx.back();
4632+                        bool flood_tx = pto->m_tx_relay->m_txs_to_announce.at(hash);

119@@ -120,6 +120,13 @@ class TxReconciliationTracker::Impl {
120      */
121     std::unordered_map<NodeId, ReconciliationState> m_states GUARDED_BY(m_mutex);
122 
123+    /**
124+     * Maintains a queue of reconciliations we should initiate. To achieve higher bandwidth
125+     * conservation and avoid overflows, we should reconcile in the same order, because then it’s
126+     * easier to estimate set differene size.

134@@ -127,6 +135,16 @@ class TxReconciliationTracker::Impl {
135      */
136     std::deque<NodeId> m_queue GUARDED_BY(m_mutex);
137 
138+    /**
139+     * Reconciliations are requested periodically:
140+     * every RECON_REQUEST_INTERVAL seconds we pick a peer from the queue.
141+     */
142+    std::chrono::microseconds m_next_recon_request{0};

140+     * every RECON_REQUEST_INTERVAL seconds we pick a peer from the queue.
141+     */
142+    std::chrono::microseconds m_next_recon_request{0};
143+    void UpdateNextReconRequest(std::chrono::microseconds now) EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
144+    {
145+        m_next_recon_request = now + RECON_REQUEST_INTERVAL / m_queue.size();

33@@ -27,6 +34,14 @@ constexpr uint32_t MAX_OUTBOUND_FLOOD_TO = 8;
34  */
35 constexpr std::chrono::microseconds RECON_REQUEST_INTERVAL{16s};
36 
37+/**
38+ * Represents phase of the current reconciliation round with a peer.
39+ */
40+enum ReconciliationPhase {

52+    /**
53+     * Relay transaction to every node.
54+     * The announcement protocol (flooding or reconciliation) will be chosen based on from which
55+     * peer the transaction came to us. For transactions originated locally, pass from=nullopt.
56+     */
57+    virtual void RelayTransaction(const uint256& txid, const uint256& wtxid, std::optional<NodeId> from=std::nullopt)

371@@ -365,6 +372,9 @@ class PeerManagerImpl final : public PeerManager
372     /** Number of peers with wtxid relay. */
373     int m_wtxid_relay_peers GUARDED_BY(cs_main) = 0;
374 
375+    /** Number of outbound peers we may flood transactions to. */
376+    int m_out_flood_to GUARDED_BY(cs_main) = 0;

606@@ -597,6 +607,9 @@ struct CNodeState {
607     //! Whether this peer relays txs via wtxid
608     bool m_wtxid_relay{false};
609 
610+    //! Whether this peer may be used by us for flooding txs.
611+    bool m_we_may_flood_to{false};

2062@@ -2017,8 +2063,9 @@ void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
2063  *                                  orphan will be reconsidered on each call of this function. This set
2064  *                                  may be added to if accepting an orphan causes its children to be
2065  *                                  reconsidered.
2066+ * @param           from            The peer for which we are processing the orphan set.
2067  */
2068-void PeerManagerImpl::ProcessOrphanTx(std::set<uint256>& orphan_work_set)
2069+void PeerManagerImpl::ProcessOrphanTx(std::set<uint256>& orphan_work_set, NodeId from)

26+ *    required because the initiator knows only short IDs of those transactions.
27+ * 5. Sometimes reconciliation fails if the difference is larger than the parties estimated,
28+ *    then there is one sketch extension round, in which the initiator requests for extra data.
29+ * 6. If extension succeeds, go to step 4.
30+ * 7. If extension fails, the initiator notifies the peer
31+ */

27+ * 5. Sometimes reconciliation fails if the difference is larger than the parties estimated,
28+ *    then there is one sketch extension round, in which the initiator requests for extra data.
29+ * 6. If extension succeeds, go to step 4.
30+ * 7. If extension fails, the initiator notifies the peer
31+ */
32+class TxReconciliationTracker {

130+static constexpr auto INBOUND_INVENTORY_BROADCAST_INTERVAL = 2s;
131 /** Average delay between trickled inventory transmissions for outbound peers.
132  *  Use a smaller delay as there is less privacy concern for them.
133  *  Blocks and peers with noban permission bypass this. */
134-static constexpr auto OUTBOUND_INVENTORY_BROADCAST_INTERVAL = 2s;
135+static constexpr auto OUTBOUND_INVENTORY_BROADCAST_INTERVAL = 1s;

1550+        // inbounds* (see above), so non-reachable nodes would never flood any transactions.
1551+        // Now, if they flood their local transactions, it will be obvious for their immediate peers
1552+        // that those transactions belong to those non-reachable nodes.
1553+        //
1554+        // On the other hand, if non-reachable nodes reconcile those transactions, they would look
1555+        // like any other transactions of non-reachable nodes.

2388+    std::vector<CInv> remote_missing_invs;
2389+    remote_missing_invs.reserve(std::min<size_t>(remote_missing_wtxids.size(), MAX_INV_SZ));
2390+
2391+    while (!remote_missing_wtxids.empty()) {
2392+        // No need to add transactions to peer's filter or do checks
2393+        // because it was already done when adding to the reconciliation set.

2401+            remote_missing_invs.clear();
2402+        }
2403+    }
2404+
2405+    if (remote_missing_invs.size() != 0) {
2406+        m_connman.PushMessage(&pto, msgMaker.Make(NetMsgType::INV, remote_missing_invs));

33+MAX_OUTBOUND_FLOOD_TO = 8
34+
35+BYTES_PER_SKETCH_CAPACITY = FIELD_BITS / 8
36+
37+#################################
38+######## General helpers ########

2792+        uint32_t recon_version;
2793+        uint64_t remote_salt;
2794+        vRecv >> they_initiator >> they_responder >> recon_version >> remote_salt;
2795+
2796+        // Since this is called before VERACK, m_out_flooding_peers doesn't include this peer
2797+        // being considered for reconciliation support, so no need for substraction.

3998+                // we want to request extension).
3999+                m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::RECONCILDIFF,
4000+                    *recon_result, txs_to_request));
4001+            } else {
4002+                // No final result means we should request sketch extension to make another
4003+                // reconciliation attempt without loosing the initial data.

475+
476+        self.test_node = self.nodes[0].add_p2p_connection(TestP2PConn(recon_version=1,
477+            mininode_salt=MININODE_SALT, be_recon_requestor=False, be_recon_responder=True), node_outgoing=True)
478+        self.test_node.wait_for_verack()
479+
480+        self.blocks = self.nodes[0].generate(nblocks=1024)

2780+            return;
2781+        }
2782+
2783+        LOCK(cs_main);
2784+        if (!State(pfrom.GetId())->m_wtxid_relay) {
2785+            // Disconnect peers that send a SENDRECON message before/without WTXIDRELAY.

2653+                        we_may_flood_to = true;
2654+                    }
2655+                } else {
2656+                    // All non-reconciling peers which pass the MightSupportTransactionRelay and
2657+                    // !IsInboundConn checks are outbound flooding peers.
2658+                    we_may_flood_to = true;

2794+        vRecv >> they_initiator >> they_responder >> recon_version >> remote_salt;
2795+
2796+        // Since this is called before VERACK, m_out_flooding_peers doesn't include this peer
2797+        // being considered for reconciliation support, so no need for substraction.
2798+        m_reconciliation.EnableReconciliationSupport(pfrom.GetId(), pfrom.IsInboundConn(),
2799+            they_initiator, they_responder, recon_version, remote_salt, m_out_flood_to);

42+/**
43+ * When considering whether we should flood to an outbound connection supporting reconciliation,
44+ * see how many outbound connections are already used for flooding. Flood only if the limit is not reached.
45+ * It helps to save bandwidth and reduce the privacy leak.
46+ */
47+constexpr uint32_t MAX_OUTBOUND_FLOOD_TO = 8;

4780+                            // We don't care about a laggy peer (1) because we probably can't help them even if we flood transactions.
4781+                            // However, exploiting (2) should not prevent us from relaying certain transactions.
4782+                            //
4783+                            // Transactions which don't make it to the set due to the limit are announced via flooding.
4784+                            const size_t recon_set_size = *m_reconciliation.GetPeerSetSize(pto->GetId());
4785+                            if (txs_to_reconcile.size() + recon_set_size < MAX_PEER_TX_ANNOUNCEMENTS) {

4740@@ -4525,12 +4741,12 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
4741                     while (!vInvTx.empty() && nRelayedTransactions < INVENTORY_BROADCAST_MAX) {
4742                         // Fetch the top element from the heap
4743                         std::pop_heap(vInvTx.begin(), vInvTx.end(), compareInvMempoolOrder);
4744-                        std::set<uint256>::iterator it = vInvTx.back();
4745+                        uint256 hash = vInvTx.back();
4746+                        const bool flood_tx = pto->m_tx_relay->m_txs_to_announce.at(hash);

4785+                            if (txs_to_reconcile.size() + recon_set_size < MAX_PEER_TX_ANNOUNCEMENTS) {
4786+                                // Check that:
4787+                                // 1) the peer isn't set for flooding OR
4788+                                // 2) the transaction isn't set for flooding
4789+                                const bool recon_peer_flood_to = *m_reconciliation.IsPeerChosenForFlooding(pto->GetId());
4790+                                if (!recon_peer_flood_to || !flood_tx) {

4678+                    if (!supports_recon && pto->IsInboundConn()) {
4679                         pto->m_tx_relay->nNextInvSend = m_connman.PoissonNextSendInbound(current_time, INBOUND_INVENTORY_BROADCAST_INTERVAL);
4680                     } else {
4681+                        // Use half the delay for outbound peers, as there is less privacy concern for them.
4682+                        // Also use half delay for inbound peers if they use reconciliations,
4683+                        // because we have an additional delay for sending out requested sketches.

488+            recon_state->second.FinalizeInitByUs(true, DEFAULT_RECON_Q);
489+            recon_state->second.m_state_init_by_us.m_phase = Phase::NONE;
490+
491+            result = false;
492+
493+            LogPrint(BCLog::NET, "Reconciliation we initiated with peer=%d terminated due to empty sketch." /* Continue */

3966@@ -3800,6 +3967,68 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
3967         return;
3968     }
3969 
3970+    if (msg_type == NetMsgType::REQRECON) {
3971+        uint16_t peer_recon_set_size, peer_q;

3996+            }
3997+            AnnounceTxs(txs_to_announce, pfrom);
3998+        } else {
3999+            // Disconnect peers that send reconciliation sketch violating the protocol.
4000+            LogPrint(BCLog::NET, "sketch from peer=%d violates reconciliation protocol; disconnecting\n", pfrom.GetId());
4001+            pfrom.fDisconnect = true;

3966@@ -3800,6 +3967,68 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
3967         return;
3968     }
3969 
3970+    if (msg_type == NetMsgType::REQRECON) {
3971+        uint16_t peer_recon_set_size, peer_q;
3972+        vRecv >> peer_recon_set_size >> peer_q;
3973+        m_reconciliation.HandleReconciliationRequest(pfrom.GetId(), peer_recon_set_size, peer_q);

806+        // returning values
807+        std::vector<uint32_t>& txs_to_request, std::vector<uint256>& txs_to_announce, std::optional<bool>& result)
808+    {
809+        uint16_t remote_sketch_capacity = uint16_t(skdata.size() / BYTES_PER_SKETCH_CAPACITY);
810+        // Protocol violation: our peer exceeded the sketch capacity, or sent a malformed sketch.
811+        if (remote_sketch_capacity > MAX_SKETCH_CAPACITY) {

4847+        //
4848+        // Message: reconciliation response
4849+        //
4850+        {
4851+            std::vector<uint8_t> skdata;
4852+            bool respond = m_reconciliation.RespondToReconciliationRequest(pto->GetId(), skdata);

4021+        if (valid_finalization) {
4022+            AnnounceTxs(remote_missing, pfrom);
4023+        } else {
4024+            // Disconnect peers that send reconciliation finalization violating the protocol.
4025+            LogPrint(BCLog::NET, "reconcildiff from peer=%d violates reconciliation protocol; disconnecting\n", pfrom.GetId());
4026+            pfrom.fDisconnect = true;

15+    msg_inv, msg_getdata, msg_wtxidrelay,
16+    msg_verack, msg_sendrecon, msg_reqrecon,
17+    msg_sketch, msg_reqsketchext, msg_reconcildiff,
18+    MSG_WTX, CTransaction, CInv,
19+)
20+from test_framework.p2p import P2PDataStore, MIN_P2P_VERSION_SUPPORTED

2803+        }
2804+
2805+        if (pfrom.GetCommonVersion() < RECONCILIATION_RELAY_VERSION) {
2806+            LogPrint(BCLog::NET, "ignoring sendrecon due to old common version=%d from peer=%d\n", pfrom.GetCommonVersion(), pfrom.GetId());
2807+            return;
2808+        }

55+     * - whether we agree to respond to reconciliation requests (send our sketches)
56+     * - reconciliation protocol version
57+     * - salt used for short ID computation required for reconciliation
58+     * A peer can't be registered for future reconciliations without this call.
59+     */
60+    std::tuple<bool, bool, uint32_t, uint64_t> SuggestReconciling(NodeId peer_id, bool inbound);

129+{
130+    TxReconciliationTracker tracker;
131+
132+    auto [we_initiate_recon, we_respond_recon, recon_version, recon_salt] = tracker.SuggestReconciling(0, true);
133+    assert(!we_initiate_recon);
134+    assert(we_respond_recon);

138+    assert(!we_respond_recon);
139+}
140+
141+BOOST_AUTO_TEST_CASE(EnableReconciliationSupportTest)
142+{
143+    TxReconciliationTracker tracker;

625+        // for the second time should not happen
626+        LOCK(m_mutex);
627+        if (m_states.find(peer_id) != m_states.end()) return;
628+
629+        recon_version = std::min(recon_version, RECON_VERSION);
630+        if (recon_version < 1) return;

143+    TxReconciliationTracker tracker;
144+    const uint64_t salt = 0;
145+
146+    // Test inbound peers.
147+    bool inbound = true;
148+

641+        bool we_initiate = we_may_initiate && they_may_respond;
642+        // If we ever announce we_initiate && we_may_respond, this will need tie-breaking. For now,
643+        // this is mutually exclusive because both are based on the inbound flag.
644+        assert(!(they_initiate && we_initiate));
645+
646+        if (!(they_initiate || we_initiate)) return;

262+    SetMockTime(start_time + 20000);
263+    // Still don't request because the other peer is earlier in the queue.
264+    assert(!tracker.MaybeRequestReconciliation(peer_id2));
265+    tracker.RemovePeer(peer_id1);
266+    assert(tracker.MaybeRequestReconciliation(peer_id2));
267+}

713+    {
714+        LOCK(m_mutex);
715+        auto recon_state = m_states.find(peer_id);
716+        if (recon_state == m_states.end()) return;
717+        if (recon_state->second.m_state_init_by_them.m_phase != Phase::NONE) return;
718+        if (recon_state->second.m_we_initiate) return;

310+    // The node receives a reconciliation request noting that the initiator has an empty set.
311+    // The node should terminate reconciliation by sending an empty sketch.
312+    TxReconciliationTrackerTest tracker_test(true);
313+    tracker_test.HandleReconciliationRequest(1);
314+    SetMockTime(start_time + 2000);
315+    assert(tracker_test.RespondToReconciliationRequest(skdata));

278+    assert(!tracker.RespondToReconciliationRequest(peer_id0, skdata));
279+
280+    // Request from a non-initiating peer should be ignored.
281+    TxReconciliationTrackerTest tracker_test1(false);
282+    tracker_test1.HandleReconciliationRequest();
283+    SetMockTime(start_time + 4000);

310+    assert(tracker.EnableReconciliationSupport(peer_id0, true, true, false, 1, 0));
311+    tracker.HandleReconciliationRequest(peer_id0, 1, 1);
312+    SetMockTime(start_time + 1000);
313+    tracker.RemovePeer(peer_id0);
314+    assert(!tracker.RespondToReconciliationRequest(peer_id0, skdata));
315+

319+    tracker_test.HandleReconciliationRequest(1);
320+    SetMockTime(start_time + 2000);
321+    assert(tracker_test.RespondToReconciliationRequest(skdata));
322+    assert(skdata.size() == 0);
323+
324+    // The node receives a reconciliation request noting that their local set is empty.

324+    // The node receives a reconciliation request noting that their local set is empty.
325+    // The node should terminate reconciliation by sending an empty sketch.
326+    TxReconciliationTrackerTest tracker_test2(true);
327+    tracker_test2.AddTransactions(5);
328+    tracker_test2.HandleReconciliationRequest(0);
329+    SetMockTime(start_time + 3000);

315+     */
316+    Minisketch ComputeBaseSketch(uint32_t& capacity)
317+    {
318+        Minisketch sketch;
319+        // Avoid serializing/sending an empty sketch.
320+        if (m_local_set.GetSize() == 0 || capacity == 0) return sketch;

340+    uint32_t expected_capacity = (10 - 1) + q * 1 + 1;
341+    Minisketch expected_sketch = tracker_test3.ComputeSketch(tracker_test3.m_transactions, expected_capacity);
342+    assert(skdata == expected_sketch.Serialize());
343+    // Then respond with an extension sketch.
344+    tracker_test3.HandleExtensionRequest();
345+    assert(tracker_test3.RespondToReconciliationRequest(skdata));

765+        // Update local reconciliation state for the peer.
766+        recon_state->second.m_state_init_by_them.m_phase = Phase::EXT_RESPONDED;
767+
768+        // Local extension sketch can be null only if initial sketch or initial capacity was 0,
769+        // in which case we would have terminated reconciliation already.
770+        uint32_t extended_capacity = std::min(uint32_t(recon_state->second.m_capacity_snapshot * 2), MAX_SKETCH_CAPACITY * 2);

389+    std::vector<uint32_t> txs_to_request;
390+    std::vector<uint256> txs_to_announce;
391+    std::optional<bool> recon_result;
392+
393+    // Protocol violation: unknown peer.
394+    assert(!tracker_test.HandleSketch(std::vector<uint8_t>(), txs_to_request, txs_to_announce, recon_result, true));

390+    std::vector<uint256> txs_to_announce;
391+    std::optional<bool> recon_result;
392+
393+    // Protocol violation: unknown peer.
394+    assert(!tracker_test.HandleSketch(std::vector<uint8_t>(), txs_to_request, txs_to_announce, recon_result, true));
395+

472+        }
473+
474+        Minisketch local_sketch = recon_state->second.ComputeBaseSketch(remote_sketch_capacity);
475+        Minisketch remote_sketch;
476+        if (remote_sketch_capacity != 0) {
477+            remote_sketch = Minisketch(RECON_FIELD_SIZE, 0, remote_sketch_capacity).Deserialize(skdata);

510+            recon_state->second.m_local_set.GetRelevantIDsFromShortIDs(differences, txs_to_request, txs_to_announce);
511+
512+            // Update local reconciliation state for the peer.
513+            size_t local_set_size = recon_state->second.m_local_set.GetSize();
514+            recon_state->second.FinalizeInitByUs(true,
515+                RecomputeQ(local_set_size, txs_to_request.size(), txs_to_announce.size()));

34+*/
35+constexpr unsigned int RECON_FALSE_POSITIVE_COEF = 16;
36+static_assert(RECON_FALSE_POSITIVE_COEF <= 256,
37+    "Reducing reconciliation false positives beyond 1 in 2**256 is not supported");
38+/** Default value for the coefficient used to estimate reconciliation set differences. */
39+constexpr double DEFAULT_RECON_Q = 0.02;

29@@ -30,8 +30,8 @@ Drag Bitcoin Core to your applications folder, and then run Bitcoin Core.
30 
31 * See the documentation at the [Bitcoin Wiki](https://en.bitcoin.it/wiki/Main_Page)
32 for help and more information.
33-* Ask for help on the [Bitcoin StackExchange](https://bitcoin.stackexchange.com)
34-* Ask for help on [#bitcoin](https://webchat.freenode.net/#bitcoin) on Freenode. If you don't have an IRC client, use [webchat here](https://webchat.freenode.net/#bitcoin).
35+* Ask for help on [Bitcoin StackExchange](https://bitcoin.stackexchange.com).

338-    parser.add_argument('--keepcache', '-k', action='store_true', help='the default behavior is to flush the cache directory on startup. --keepcache retains the cache from the previous testrun.')
339-    parser.add_argument('--quiet', '-q', action='store_true', help='only print dots, results summary and failure logs')
340-    parser.add_argument('--tmpdirprefix', '-t', default=tempfile.gettempdir(), help="Root directory for datadirs")
341-    parser.add_argument('--failfast', action='store_true', help='stop execution after the first test failure')
342-    parser.add_argument('--filter', help='filter scripts to run by regular expression')
343+    parser.add_argument('--ansi', action='store_true', default=sys.stdout.isatty(),

27+constexpr unsigned int BYTES_PER_SKETCH_CAPACITY = RECON_FIELD_SIZE / 8;
28+/**
29+ * Limit sketch capacity to avoid DoS. This applies only to the original sketches,
30+ * and implies that extended sketches could be at most twice the size.
31+ */
32+constexpr uint32_t MAX_SKETCH_CAPACITY = 2 << 12;

139@@ -140,6 +140,7 @@ BITCOIN_TESTS =\
140   test/transaction_tests.cpp \
141   test/txindex_tests.cpp \
142   test/txpackage_tests.cpp \
143+  test/txreconciliation_tests.cpp \