p2p: Erlay support signaling #23443

2575@@ -2574,6 +2576,15 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
2576 
2577         if (greatest_common_version >= WTXID_RELAY_VERSION) {
2578             m_connman.PushMessage(&pfrom, msg_maker.Make(NetMsgType::WTXIDRELAY));
2579+
2580+            // Reconciliation is supported only when wtxid relay is supported for only

261@@ -262,6 +262,13 @@ extern const char* CFCHECKPT;
262  * @since protocol version 70016 as described by BIP 339.
263  */
264 extern const char* WTXIDRELAY;
265+/**
266+ * Contains 2 1-byte bools, a 4-byte version number and an 8-byte salt.
267+ * Indicates that a node is willing to participate in transaction reconciliation,

31+
32+    std::tuple<bool, bool, uint32_t, uint64_t> PreRegisterPeer(NodeId peer_id, bool peer_inbound)
33+    {
34+        bool we_initiate_recon, we_respond_recon;
35+        // Currently reconciliation roles are defined by the connection direction: only the inbound
36+        // peer initiate reconciliations and the outbound peer is supposed to only respond.

18+ * to compute transaction short IDs, which are then used to construct a sketch representing a set
19+ * of transactions we want to announce to the peer.
20+ */
21+static uint256 ComputeSalt(uint64_t local_salt, uint64_t remote_salt)
22+{
23+    // Accoring to BIP-330, salts should be combined in ascending order.

2821@@ -2822,6 +2822,48 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
2822         return;
2823     }
2824 
2825+    // Received from a peer demonstrating readiness to announce transactions via reconciliations.
2826+    // This feature negotiation should happen:
2827+    // - between VERSION and VERACK to avoid relay problems from switching annoyncement protocols

2834+            pfrom.fDisconnect = true;
2835+            return;
2836+        }
2837+
2838+        if (!pfrom.m_tx_relay) {
2839+            // If we chose a peer to not send us transactions, disconnect if they want to reconcile.

104+        bool they_may_initiate, bool they_may_respond, uint32_t recon_version, uint64_t remote_salt)
105+    {
106+        // We do not support reconciliation salt/version updates. We treat an attempt to update
107+        // after a successful registration as a protocol violation.
108+        LOCK(m_mutex);
109+        if (m_states.find(peer_id) != m_states.end()) return false;

112+        // they support. For now, this only guarantees that nodes with future reconciliation
113+        // versions have the choice of reconciling with this current version. However, they also
114+        // have the choice to refuse supporting reconciliations if the common version is not
115+        // satisfactory (e.g. too low).
116+        recon_version = std::min(recon_version, RECON_VERSION);
117+        // v1 is the lowest version, so suggesting something below must be a protocol violation.

148     {
149         LOCK(m_mutex);
150-        if (m_local_salts.erase(peer_id)) {
151+        auto salt_erased = m_local_salts.erase(peer_id);
152+        auto state_erased = m_states.erase(peer_id);
153+        if (salt_erased || state_erased) {

19+    assert(we_respond_recon);
20+    assert(recon_version == 1); // RECON_VERSION in src/txreconciliation.cpp
21+
22+    std::tie(we_initiate_recon, we_respond_recon, recon_version, recon_salt) = tracker.PreRegisterPeer(1, false);
23+    assert(we_initiate_recon);
24+    assert(!we_respond_recon);

367@@ -367,6 +368,7 @@ libbitcoin_server_a_SOURCES = \
368   txdb.cpp \
369   txmempool.cpp \
370   txorphanage.cpp \
371+  txreconciliation.cpp \

266+ * Contains 2 1-byte bools, a 4-byte version number and an 8-byte salt.
267+ * The boolean indicates that a node is willing to participate in transaction
268+ * reconciliation, either as a sender or a receiver.
269+ * The salt is used to compute short txids needed for efficient reconciliation.
270+ */
271+extern const char *SENDRECON;

2833+            LogPrint(BCLog::NET, "sendrecon received after verack from peer=%d; disconnecting\n", pfrom.GetId());
2834+            pfrom.fDisconnect = true;
2835+            return;
2836+        }
2837+
2838+        if (!pfrom.m_tx_relay) {

18+ * 0. Reconciliation protocol handshake.
19+ * 1. Once we receive a new transaction, add it to the set instead of announcing immediately
20+ * 2. When the time comes, a reconciliation initiator requests a sketch from the peer, where a sketch
21+ *    is a compressed representation of their set
22+ * 3. Once the initiator received a sketch from the peer, the initiator computes a local sketch,
23+ *    and combines the two skethes to find the difference in *sets*.

15+ * Transaction reconciliation is a way for nodes to efficiently announce transactions.
16+ * This object keeps track of all reconciliation-related communications with the peers.
17+ * The high-level protocol is:
18+ * 0. Reconciliation protocol handshake.
19+ * 1. Once we receive a new transaction, add it to the set instead of announcing immediately
20+ * 2. When the time comes, a reconciliation initiator requests a sketch from the peer, where a sketch

16+ * This object keeps track of all reconciliation-related communications with the peers.
17+ * The high-level protocol is:
18+ * 0. Reconciliation protocol handshake.
19+ * 1. Once we receive a new transaction, add it to the set instead of announcing immediately
20+ * 2. When the time comes, a reconciliation initiator requests a sketch from the peer, where a sketch
21+ *    is a compressed representation of their set

23+ *    and combines the two skethes to find the difference in *sets*.
24+ * 4. Now the initiator knows full symmetrical difference and can request what the initiator is
25+ *    missing and announce to the peer what the peer is missing. For the former, an extra round is
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.

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 and announces all transactions from the
31+ *    corresponding set. Once the peer received the failure notification, the peer announces all
32+ *    transactions from the corresponding set.

91+        } else {
92+            we_initiate_recon = true;
93+            we_respond_recon = false;
94+        }
95+
96+        uint64_t m_local_recon_salt(GetRand(UINT64_MAX));

19+ * of transactions we want to announce to the peer.
20+ */
21+static uint256 ComputeSalt(uint64_t local_salt, uint64_t remote_salt)
22+{
23+    // According to BIP-330, salts should be combined in ascending order.
24+    uint64_t salt1 = local_salt, salt2 = remote_salt;

123+        auto local_salt = m_local_salts.find(peer_id);
124+
125+        // This function should be called only after generating the local salt.
126+        if (local_salt == m_local_salts.end()) return false;
127+
128+        // Must match SuggestReconciling logic.

18+ * 0. Reconciliation protocol handshake.
19+ * 1. Once we receive a new transaction, add it to the set instead of announcing immediately
20+ * 2. When the time comes, a reconciliation initiator requests a sketch from the peer, where a sketch
21+ *    is a compressed representation of their set
22+ * 3. Once the initiator received a sketch from the peer, the initiator computes a local sketch,
23+ *    and combines the two skethes to find the difference in *sets*.

261@@ -262,6 +262,13 @@ extern const char* CFCHECKPT;
262  * @since protocol version 70016 as described by BIP 339.
263  */
264 extern const char* WTXIDRELAY;
265+/**
266+ * Contains 2 1-byte bools, a 4-byte version number and an 8-byte salt.
267+ * The boolean indicates that a node is willing to participate in transaction
268+ * reconciliation, either as a sender or a receiver.

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 and announces all transactions from the
31+ *    corresponding set. Once the peer received the failure notification, the peer announces all
32+ *    transactions from the corresponding set.

2847+        if (!State(pfrom.GetId())->m_wtxid_relay) {
2848+            // Disconnect peers that send a SENDRECON message before/without WTXIDRELAY.
2849+            LogPrint(BCLog::NET, "sendrecon received before wtxidrelay peer=%d; disconnecting\n", pfrom.GetId());
2850+            pfrom.fDisconnect = true;
2851+            return;
2852+        }

121+        if (recon_version < 1) return false;
122+
123+        auto local_salt = m_local_salts.find(peer_id);
124+
125+        // This function should be called only after generating the local salt.
126+        if (local_salt == m_local_salts.end()) return false;

56@@ -57,6 +57,14 @@ class TxReconciliationTracker {
57      * This function must be called only once per peer.
58      */
59     std::tuple<bool, bool, uint32_t, uint64_t> PreRegisterPeer(NodeId peer_id, bool peer_inbound);
60+
61+    // Helpers
62+
63+    /**
64+     * Attempts to forget reconciliation-related state of the peer (if we previously stored any).
65+     * After this, we won't be able to reconcile with the peer.

48+
49+    /**
50+     * Reconciliation protocol assumes using one role consistently: either a reconciliation
51+     * initiator (requesting sketches), or responder (sending sketches). This defines our role.
52+     * */
53+    const bool m_we_initiate;

13+BOOST_AUTO_TEST_CASE(PreRegisterPeerTest)
14+{
15+    TxReconciliationTracker tracker;
16+
17+    auto [we_initiate_recon, we_respond_recon, recon_version, recon_salt] = tracker.PreRegisterPeer(0, true);
18+    assert(!we_initiate_recon);

64+    NodeId peer_id0 = 0;
65+
66+    // Removing peer after pre-registring works and does not let to register the peer.
67+    tracker.PreRegisterPeer(peer_id0, true);
68+    tracker.ForgetPeer(peer_id0);
69+    assert(!tracker.RegisterPeer(peer_id0, true, true, false, 1, 1));

1813@@ -1814,3 +1814,31 @@ def serialize(self):
1814     def __repr__(self):
1815         return "msg_cfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
1816             self.filter_type, self.stop_hash)
1817+
1818+class msg_sendrecon:

2854+        bool they_initiator, they_responder;
2855+        uint32_t recon_version;
2856+        uint64_t remote_salt;
2857+        vRecv >> they_initiator >> they_responder >> recon_version >> remote_salt;
2858+
2859+        if (!m_reconciliation.RegisterPeer(pfrom.GetId(), pfrom.IsInboundConn(),

59+    std::tuple<bool, bool, uint32_t, uint64_t> PreRegisterPeer(NodeId peer_id, bool peer_inbound);
60+
61+    /**
62+     * Step 0. Once the peer agreed to reconcile with us, generate the state required to track
63+     * ongoing reconciliations. Should be called only after pre-registering the peer and only once.
64+     * Does nothing and returns false if the peer violates the protocol.

23+    // According to BIP-330, salts should be combined in ascending order.
24+    uint64_t salt1 = local_salt, salt2 = remote_salt;
25+    if (salt1 > salt2) std::swap(salt1, salt2);
26+
27+    static const auto RECON_SALT_HASHER = TaggedHash(RECON_STATIC_SALT);
28+    return (CHashWriter(RECON_SALT_HASHER) << salt1 << salt2).GetSHA256();

109+        // We do not support reconciliation salt/version updates. We treat an attempt to update
110+        // after a successful registration as a protocol violation.
111+        LOCK(m_mutex);
112+        if (m_states.find(peer_id) != m_states.end()) return false;
113+
114+        // If the peer supports the version which is lower than our, we downgrade to the version

127+
128+        // Must match SuggestReconciling logic.
129+        bool we_may_initiate = !peer_inbound, we_may_respond = peer_inbound;
130+
131+        bool they_initiate = they_may_initiate && we_may_respond;
132+        bool we_initiate = we_may_initiate && they_may_respond;

133+        // If we ever announce we_initiate && we_may_respond, this will need tie-breaking. For now,
134+        // this is mutually exclusive because both are based on the inbound flag.
135+        assert(!(they_initiate && we_initiate));
136+
137+        // The peer set both flags to false, we treat it as a protocol violation.
138+        if (!(they_initiate || we_initiate)) return false;

47+        bool added = WITH_LOCK(m_mutex, return m_local_salts.emplace(peer_id, m_local_recon_salt).second);
48+        // We do this exactly once per peer (which are unique by NodeId, see GetNewNodeId) so it's
49+        // safe to assume we don't have this record yet.
50+        assert(added);
51+
52+        LogPrint(BCLog::NET, "Pre-register peer=%d for reconciling.\n", peer_id);

34+ * This is a modification of the Erlay protocol (https://arxiv.org/abs/1905.10518) with two
35+ * changes (sketch extensions instead of bisections, and an extra INV exchange round), both
36+ * are motivated in BIP-330.
37+ */
38+class TxReconciliationTracker {
39+    // Avoid littering this header file with implementation details.

38+class TxReconciliationTracker {
39+    // Avoid littering this header file with implementation details.
40+    class Impl;
41+    const std::unique_ptr<Impl> m_impl;
42+
43+    public:

40+    class Impl;
41+    const std::unique_ptr<Impl> m_impl;
42+
43+    public:
44+
45+    explicit TxReconciliationTracker();

33+ * peer when next transaction reconciliation happens, and also all parameters required to perform
34+ * reconciliations.
35+ */
36+class ReconciliationState {
37+
38+    public:

0@@ -0,0 +1,192 @@
1+// Copyright (c) 2021 The Bitcoin Core developers
2+// Distributed under the MIT software license, see the accompanying
3+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4+
5+#include <node/txreconciliation.h>

107+        bool they_may_initiate, bool they_may_respond, uint32_t recon_version, uint64_t remote_salt)
108+    {
109+        // We do not support reconciliation salt/version updates. We treat an attempt to update
110+        // after a successful registration as a protocol violation.
111+        LOCK(m_mutex);
112+        if (m_states.find(peer_id) != m_states.end()) return false;

37+
38+    public:
39+
40+    /**
41+     * Reconciliation involves exchanging sketches, which efficiently represent transactions each
42+     * peer wants to announce. Sketches are computed over transaction short IDs.

 97+        bool added = WITH_LOCK(m_mutex, return m_local_salts.emplace(peer_id, m_local_recon_salt).second);
 98+        // We do this exactly once per peer (which are unique by NodeId, see GetNewNodeId) so it's
 99+        // safe to assume we don't have this record yet.
100+        assert(added);
101+
102+        LogPrint(BCLog::NET, "Pre-register peer=%d for reconciling.\n", peer_id);

89+            we_initiate_recon = false;
90+            we_respond_recon = true;
91+        } else {
92+            we_initiate_recon = true;
93+            we_respond_recon = false;
94+        }

 98+        // We do this exactly once per peer (which are unique by NodeId, see GetNewNodeId) so it's
 99+        // safe to assume we don't have this record yet.
100+        assert(added);
101+
102+        LogPrint(BCLog::NET, "Pre-register peer=%d for reconciling.\n", peer_id);
103+        return std::make_tuple(we_initiate_recon, we_respond_recon, RECON_VERSION, m_local_recon_salt);

68+     * construct reconciliation sketches.
69+     * Salt is generated randomly per-peer to prevent:
70+     * - linking of network nodes belonging to the same physical node
71+     * - halting of relay of particular transactions due to short ID collisions (DoS)
72+     */
73+    std::unordered_map<NodeId, uint64_t> m_local_salts GUARDED_BY(m_mutex);

2824@@ -2810,6 +2825,49 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
2825         return;
2826     }
2827 
2828+    // Received from a peer demonstrating readiness to announce transactions via reconciliations.
2829+    // This feature negotiation should happen:
2830+    // - between VERSION and VERACK to avoid relay problems from switching announcement protocols
2831+    //   after the connection is up
2832+    // - after WTXID because we reconcile only with peers supporting wtxid-relay

64+     * Does nothing and returns false if the peer violates the protocol.
65+     */
66+    bool RegisterPeer(NodeId peer_id, bool peer_inbound,
67+        bool recon_requestor, bool recon_responder, uint32_t recon_version, uint64_t remote_salt);
68+
69+    // Helpers

20+ */
21+static uint256 ComputeSalt(uint64_t local_salt, uint64_t remote_salt)
22+{
23+    // According to BIP-330, salts should be combined in ascending order.
24+    uint64_t salt1 = local_salt, salt2 = remote_salt;
25+    if (salt1 > salt2) std::swap(salt1, salt2);

16+/**
17+ * Salt (specified by BIP-330) constructed from contributions from both peers. It is used
18+ * to compute transaction short IDs, which are then used to construct a sketch representing a set
19+ * of transactions we want to announce to the peer.
20+ */
21+static uint256 ComputeSalt(uint64_t local_salt, uint64_t remote_salt)

2852+            LogPrint(BCLog::NET, "sendrecon received before wtxidrelay peer=%d; disconnecting\n", pfrom.GetId());
2853+            pfrom.fDisconnect = true;
2854+            return;
2855+        }
2856+
2857+        bool they_initiator, they_responder;

62+     * Step 0. Once the peer agreed to reconcile with us, generate the state required to track
63+     * ongoing reconciliations. Should be called only after pre-registering the peer and only once.
64+     * Does nothing and returns false if the peer violates the protocol.
65+     */
66+    bool RegisterPeer(NodeId peer_id, bool peer_inbound,
67+        bool recon_requestor, bool recon_responder, uint32_t recon_version, uint64_t remote_salt);

2862+        if (!m_reconciliation.RegisterPeer(pfrom.GetId(), pfrom.IsInboundConn(),
2863+            they_initiator, they_responder, recon_version, remote_salt)) {
2864+                LogPrint(BCLog::NET, "reconciliation protocol violation from peer=%d; disconnecting\n", pfrom.GetId());
2865+                pfrom.fDisconnect = true;
2866+                return;
2867+            }

124+
125+        // This function should be called only after generating the local salt.
126+        if (local_salt == m_local_salts.end()) return false;
127+
128+        // Must match SuggestReconciling logic.
129+        bool we_may_initiate = !peer_inbound, we_may_respond = peer_inbound;

1219@@ -1218,6 +1220,10 @@ void PeerManagerImpl::FinalizeNode(const CNode& node)
1220     }
1221     WITH_LOCK(g_cs_orphans, m_orphanage.EraseForPeer(nodeid));
1222     m_txrequest.DisconnectedPeer(nodeid);
1223+    // Do not check whether peer is registered for reconciliation here, but rather delegate checks
1224+    // to the module. Otherwise it's easy to skip deleting an intermediate state (e.g., we store
1225+    // salt for peers before we register them for reconciliation).

 6+
 7+#include <test/util/setup_common.h>
 8+
 9+#include <boost/test/unit_test.hpp>
10+
11+BOOST_FIXTURE_TEST_SUITE(txreconciliation_tests, BasicTestingSetup)

66+        assert_equal(peer.sendrecon_msg_received.version, 1)
67+
68+        self.log.info('SENDRECON should not be sent if block-relay-only')
69+        peer = self.nodes[0].add_outbound_p2p_connection(SendReconSender(), p2p_idx=2, connection_type="block-relay-only")
70+        time.sleep(1)
71+        assert not peer.sendrecon_msg_received

89+        time.sleep(1)
90+        assert peer.is_connected
91+        self.log.info('second SENDRECON triggers a disconnect')
92+        peer.send_message(create_sendrecon_msg())
93+        time.sleep(1)
94+        assert not peer.is_connected

17+
18+    // Prepare a peer for reconciliation.
19+    tracker.PreRegisterPeer(0);
20+
21+    // Both roles are false, don't register.
22+    assert(!tracker.RegisterPeer(0, true, false, false, 1, salt).value());

61@@ -62,6 +62,7 @@ namespace BCLog {
62         LOCK        = (1 << 24),
63         UTIL        = (1 << 25),
64         BLOCKSTORE  = (1 << 26),
65+        TXRECON  = (1 << 27),

468@@ -469,6 +469,7 @@ void SetupServerArgs(ArgsManager& argsman)
469     argsman.AddArg("-seednode=<ip>", "Connect to a node to retrieve peer addresses, and disconnect. This option can be specified multiple times to connect to multiple nodes.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
470     argsman.AddArg("-networkactive", "Enable all P2P network activity (default: 1). Can be changed by the setnetworkactive RPC command", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
471     argsman.AddArg("-timeout=<n>", strprintf("Specify socket connection timeout in milliseconds. If an initial attempt to connect is unsuccessful after this amount of time, drop it (minimum: 1, default: %d)", DEFAULT_CONNECT_TIMEOUT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
472+    argsman.AddArg("-txrecon", strprintf("Enable transaction reconciliations per BIP-330 (default: %d)", DEFAULT_TXRECON_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

2845+            // registered upon receiving SENDRECON afterwards.
2846+            // Now we are sure they won't announce WTXIDRELAY (can't happen after VERACK).
2847+            // We should clear the reconciliation state of the peer (because we support
2848+            // reconciliations only based on wtxids).
2849+            m_reconciliation.ForgetPeer(peer_id);
2850+        }

31+        if not self.manual_verack:
32+            super().on_version(message)
33+        self.version_received = True
34+
35+    def on_sendrecon(self, message):
36+        print(message)

137+        peer.wait_for_verack()
138+        peer.send_message(msg_verack())
139+        peer.send_message(create_sendrecon_msg())
140+        time.sleep(1)
141+        assert not peer.is_connected
142+

427@@ -425,6 +428,7 @@ class PeerManagerImpl final : public PeerManager
428     ChainstateManager& m_chainman;
429     CTxMemPool& m_mempool;
430     TxRequestTracker m_txrequest GUARDED_BY(::cs_main);
431+    TxReconciliationTracker m_reconciliation;

172@@ -172,6 +173,8 @@ static constexpr double MAX_ADDR_RATE_PER_SECOND{0.1};
173  *  based increments won't go above this, but the MAX_ADDR_TO_SEND increment following GETADDR
174  *  is exempt from this limit). */
175 static constexpr size_t MAX_ADDR_PROCESSING_TOKEN_BUCKET{MAX_ADDR_TO_SEND};
176+/** Supported transaction reconciliation protocol version */
177+static constexpr uint32_t RECON_VERSION = 1;

261@@ -262,6 +262,13 @@ extern const char* CFCHECKPT;
262  * @since protocol version 70016 as described by BIP 339.
263  */
264 extern const char* WTXIDRELAY;
265+/**
266+ * Contains 2 1-byte bools, a 4-byte version number and an 8-byte salt.
267+ * The 2 booleans indicate that a node is willing to participate in transaction
268+ * reconciliation, respectively as an initiator or as a receiver.
269+ * The salt is used to compute short txids needed for efficient reconciliation.

67+    std::optional<bool> RegisterPeer(NodeId peer_id, bool peer_inbound, bool recon_requestor,
68+                                     bool recon_responder, uint32_t peer_recon_version, uint64_t remote_salt);
69+
70+    /**
71+     * Attempts to forget reconciliation-related state of the peer (if we previously stored any).
72+     * After this, we won't be able to reconcile with the peer.

1252@@ -1251,6 +1253,7 @@ void PeerManagerImpl::FinalizeNode(const CNode& node)
1253     }
1254     WITH_LOCK(g_cs_orphans, m_orphanage.EraseForPeer(nodeid));
1255     m_txrequest.DisconnectedPeer(nodeid);
1256+    m_txreconciliation->ForgetPeer(nodeid);

43@@ -44,7 +44,7 @@ const char *CFHEADERS="cfheaders";
44 const char *GETCFCHECKPT="getcfcheckpt";
45 const char *CFCHECKPT="cfcheckpt";
46 const char *WTXIDRELAY="wtxidrelay";
47-const char *SENDRECON = "sendrecon";
48+const char* SENDRECON = "sendrecon";

51@@ -37,6 +52,9 @@ class TxReconciliationTracker::Impl
52 {
53     mutable Mutex m_mutex;
54 
55+    // Local protocol version
56+    uint32_t m_recon_version;

2650@@ -2645,6 +2651,23 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
2651 
2652         if (greatest_common_version >= WTXID_RELAY_VERSION) {
2653             m_connman.PushMessage(&pfrom, msg_maker.Make(NetMsgType::WTXIDRELAY));
2654+
2655+            if (m_txreconciliation) {
2656+                // Reconciliation is supported only when wtxid relay is supported for only
2657+                // those connections which (at least might) support transaction relay.
2658+                if (pfrom.m_tx_relay && !m_ignore_incoming_txs) {

2850+                // We could have optimistically pre-registered the peer on sending SENDRECON, or
2851+                // registered upon receiving SENDRECON afterwards.
2852+                // Now we are sure they won't announce WTXIDRELAY (can't happen after VERACK).
2853+                // We should clear the reconciliation state of the peer (because we support
2854+                // reconciliations only based on wtxids).
2855+                m_txreconciliation->ForgetPeer(peer_id);

2925@@ -2889,6 +2926,49 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
2926         return;
2927     }
2928 
2929+    // Received from a peer demonstrating readiness to announce transactions via reconciliations.
2930+    // This feature negotiation should happen: between VERSION and VERACK to avoid relay problems

0@@ -0,0 +1,167 @@
1+// Copyright (c) 2021 The Bitcoin Core developers

56+    uint32_t m_recon_version;
57+
58+    /**
59+     * Keeps track of reconciliation states of eligible peers.
60+     * For pre-registered peers, the locally generated salt is stored.
61+     * For registered peers, the salt is forgotten and the state is stored.

129+        self.log.info('SENDRECON after VERACK triggers a disconnect')
130+        peer = self.nodes[0].add_p2p_connection(SendReconSender(manual_verack=True), send_version=True, wait_for_verack=False)
131+        peer.wait_for_verack()
132+        peer.send_message(msg_verack())
133+        peer.send_message(create_sendrecon_msg())
134+        peer.wait_for_disconnect()

 95+        sendrecon_no_role = create_sendrecon_msg()
 96+        sendrecon_no_role.initiator = False
 97+        sendrecon_no_role.responder = False
 98+        peer = self.nodes[0].add_p2p_connection(
 99+            SendReconSender(sendrecon_msg_to_send=sendrecon_no_role),
100+            send_version=True, wait_for_verack=False)

2977+    // from switching announcement protocols after the connection is up.
2978+    if (msg_type == NetMsgType::SENDRECON) {
2979+        // For now, transaction reconciliation is an experimental feature that could be
2980+        // enabled via CLI.
2981+        if (!m_txreconciliation) {
2982+            return;

2889@@ -2864,6 +2890,19 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
2890             nCMPCTBLOCKVersion = 1;
2891             m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::SENDCMPCT, fAnnounceUsingCMPCTBLOCK, nCMPCTBLOCKVersion));
2892         }
2893+
2894+        if (m_txreconciliation) {
2895+            LOCK(cs_main);

2698+                // We announce reconciliation support only if this connection supports relaying
2699+                // transactions when they arrive (which is not the case for blocks-only nodes,
2700+                // block-relay-only connections, etc.).
2701+                // Also, we announce reconciliation support only for protocol versions above
2702+                // WTXID_RELAY per BIP-330.
2703+                if (peer->m_tx_relay && !m_ignore_incoming_txs) {

1278@@ -1277,9 +1279,16 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
1279     node.chainman = std::make_unique<ChainstateManager>();
1280     ChainstateManager& chainman = *node.chainman;
1281 
1282+    std::unique_ptr<TxReconciliationTracker> txreconciliation;
1283+    // For now, transaction reconciliation is an experimental feature that could be
1284+    // enabled via CLI.
1285+    if (gArgs.GetBoolArg("-txrecon", DEFAULT_TXRECON_ENABLE)) {