net: preferentially peer with nodes enforcing RDTS; ask DNS seed for x8000009; adapt tests

dathonohm · luke-jr · commit eea30f523a7a · 2026-04-15T20:41:52.000Z
Squash of: - b662a23198 Define a service bit for BIP148 - 0db5282edd Add questionmark to end of BIP148 service bit string, and add to bitcoin-cli - b5a77cda16 Preferentially peer with nodes enforcing RDTS; rename BIP148 references to ReducedData; adapt tests - 85289a3ac3 net: ask DNS seed for x8000009 (original: ea8c1ee) Define a service bit for BIP148 Github-Pull: bitcoin#10532 Rebased-From: cd74a23fcf9588199e196ab31bc64972400c2027 Add questionmark to end of BIP148 service bit string, and add to bitcoin-cli Preferentially peer with nodes enforcing RDTS; rename BIP148 references to ReducedData; adapt tests Combines: preferential peering (367b344), BIP148->ReducedData rename (85a78b8), service bit test fixes (f98fe90, ebe821e, 5efab4a, 4b757d8, f648a21). net: ask DNS seed for x8000009 Co-Authored-By: Luke Dashjr <luke-jr+git@utopios.org> Co-Authored-By: 3c853b6299 <3c853b6299@pm.me> Co-Authored-By: Léo Haf <leohaf@orangepill.ovh> Github-Pull: #238 Rebased-From: 983555f
diff --git a/src/init.cpp b/src/init.cpp
@@ -936,7 +936,7 @@ namespace { // Variables internal to initialization process only
 
 int nMaxConnections;
 int available_fds;
-ServiceFlags g_local_services = ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
+ServiceFlags g_local_services = ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS | NODE_REDUCED_DATA);
 int64_t peer_connect_timeout;
 std::set<BlockFilterType> g_enabled_filter_types;
 
diff --git a/src/kernel/chainparams.cpp b/src/kernel/chainparams.cpp
@@ -155,8 +155,8 @@ class CMainParams : public CChainParams {
         // release ASAP to avoid it where possible.
         vSeeds.emplace_back("seed.bitcoin.sipa.be."); // Pieter Wuille, only supports x1, x5, x9, and xd
         vSeeds.emplace_back("dnsseed.bluematt.me."); // Matt Corallo, only supports x9
-        vSeeds.emplace_back("dnsseed.bitcoin.dashjr-list-of-p2p-nodes.us."); // Luke Dashjr
-        vSeeds.emplace_back("seed.bitcoin.haf.ovh."); // Léo Haf
+        vSeeds.emplace_back("dnsseed.bitcoin.dashjr-list-of-p2p-nodes.us."); // Luke Dashjr, support BIP110 seeding (x8000009)
+        vSeeds.emplace_back("seed.bitcoin.haf.ovh."); // Léo Haf, support BIP110 seeding (x8000009)
         vSeeds.emplace_back("seed.bitcoin.jonasschnelli.ch."); // Jonas Schnelli, only supports x1, x5, x9, and xd
         vSeeds.emplace_back("seed.btc.petertodd.net."); // Peter Todd, only supports x1, x5, x9, and xd
         vSeeds.emplace_back("seed.bitcoin.sprovoost.nl."); // Sjors Provoost
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -1655,13 +1655,14 @@ bool PeerManagerImpl::HasAllDesirableServiceFlags(ServiceFlags services) const
 
 ServiceFlags PeerManagerImpl::GetDesirableServiceFlags(ServiceFlags services) const
 {
+    // We want to preferentially peer with other nodes that enforce UASF-ReducedData, in case of a chain split
     if (services & NODE_NETWORK_LIMITED) {
         // Limited peers are desirable when we are close to the tip.
         if (ApproximateBestBlockDepth() < NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS) {
-            return ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
+            return ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS | NODE_REDUCED_DATA);
         }
     }
-    return ServiceFlags(NODE_NETWORK | NODE_WITNESS);
+    return ServiceFlags(NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA);
 }
 
 PeerRef PeerManagerImpl::GetPeerRef(NodeId id) const
diff --git a/src/protocol.h b/src/protocol.h
@@ -363,7 +363,7 @@ std::vector<std::string> serviceFlagsToStr(uint64_t flags);
  * should be updated appropriately to filter for nodes with
  * desired service flags (compatible with our new flags).
  */
-constexpr ServiceFlags SeedsServiceFlags() { return ServiceFlags(NODE_NETWORK | NODE_WITNESS); }
+constexpr ServiceFlags SeedsServiceFlags() { return ServiceFlags(NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA); }
 
 /**
  * Checks if a peer with the given service flags may be capable of having a
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
@@ -1055,7 +1055,7 @@ static RPCHelpMan addpeeraddress()
 
     if (net_addr.has_value()) {
         CService service{net_addr.value(), port};
-        CAddress address{MaybeFlipIPv6toCJDNS(service), ServiceFlags{NODE_NETWORK | NODE_WITNESS}};
+        CAddress address{MaybeFlipIPv6toCJDNS(service), ServiceFlags{NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA}};
         address.nTime = Now<NodeSeconds>();
         // The source address is set equal to the address. This is equivalent to the peer
         // announcing itself.
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
@@ -68,8 +68,8 @@ BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
     connman.Handshake(
         /*node=*/dummyNode1,
         /*successfully_connected=*/true,
-        /*remote_services=*/ServiceFlags(NODE_NETWORK | NODE_WITNESS),
-        /*local_services=*/ServiceFlags(NODE_NETWORK | NODE_WITNESS),
+        /*remote_services=*/ServiceFlags(NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA),
+        /*local_services=*/ServiceFlags(NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA),
         /*version=*/PROTOCOL_VERSION,
         /*relay_txs=*/true);
 
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
@@ -865,15 +865,15 @@ BOOST_AUTO_TEST_CASE(initial_advertise_from_version_message)
                /*inbound_onion=*/false,
                /*network_key=*/2};
 
-    const uint64_t services{NODE_NETWORK | NODE_WITNESS};
+    const uint64_t services{NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA};
     const int64_t time{0};
 
     // Force ChainstateManager::IsInitialBlockDownload() to return false.
     // Otherwise PushAddress() isn't called by PeerManager::ProcessMessage().
     auto& chainman = static_cast<TestChainstateManager&>(*m_node.chainman);
     chainman.JumpOutOfIbd();
 
-    m_node.peerman->InitializeNode(peer, NODE_NETWORK);
+    m_node.peerman->InitializeNode(peer, ServiceFlags(NODE_NETWORK | NODE_REDUCED_DATA));
 
     std::atomic<bool> interrupt_dummy{false};
     std::chrono::microseconds time_received_dummy{0};
diff --git a/src/test/peerman_tests.cpp b/src/test/peerman_tests.cpp
@@ -36,7 +36,7 @@ BOOST_AUTO_TEST_CASE(connections_desirable_service_flags)
 
     // Check we start connecting to full nodes
     ServiceFlags peer_flags{NODE_WITNESS | NODE_NETWORK_LIMITED};
-    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS));
+    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA));
 
     // Make peerman aware of the initial best block and verify we accept limited peers when we start close to the tip time.
     auto tip = WITH_LOCK(::cs_main, return m_node.chainman->ActiveChain().Tip());
@@ -45,15 +45,15 @@ BOOST_AUTO_TEST_CASE(connections_desirable_service_flags)
     peerman->SetBestBlock(tip_block_height, std::chrono::seconds{tip_block_time});
 
     SetMockTime(tip_block_time + 1); // Set node time to tip time
-    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS));
+    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS | NODE_REDUCED_DATA));
 
     // Check we don't disallow limited peers connections when we are behind but still recoverable (below the connection safety window)
     SetMockTime(GetTime<std::chrono::seconds>() + std::chrono::seconds{consensus.nPowTargetSpacing * (NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS - 1)});
-    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS));
+    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS | NODE_REDUCED_DATA));
 
     // Check we disallow limited peers connections when we are further than the limited peers safety window
     SetMockTime(GetTime<std::chrono::seconds>() + std::chrono::seconds{consensus.nPowTargetSpacing * 2});
-    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS));
+    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA));
 
     // By now, we tested that the connections desirable services flags change based on the node's time proximity to the tip.
     // Now, perform the same tests for when the node receives a block.
@@ -62,15 +62,15 @@ BOOST_AUTO_TEST_CASE(connections_desirable_service_flags)
     // First, verify a block in the past doesn't enable limited peers connections
     // At this point, our time is (NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS + 1) * 10 minutes ahead the tip's time.
     mineBlock(m_node, /*block_time=*/std::chrono::seconds{tip_block_time + 1});
-    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS));
+    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA));
 
     // Verify a block close to the tip enables limited peers connections
     mineBlock(m_node, /*block_time=*/GetTime<std::chrono::seconds>());
-    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS));
+    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS | NODE_REDUCED_DATA));
 
     // Lastly, verify the stale tip checks can disallow limited peers connections after not receiving blocks for a prolonged period.
     SetMockTime(GetTime<std::chrono::seconds>() + std::chrono::seconds{consensus.nPowTargetSpacing * NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS + 1});
-    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS));
+    BOOST_CHECK(peerman->GetDesirableServiceFlags(peer_flags) == ServiceFlags(NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functional/feature_anchors.py b/test/functional/feature_anchors.py
@@ -8,7 +8,7 @@
 
 from test_framework.p2p import P2PInterface, P2P_SERVICES
 from test_framework.socks5 import Socks5Configuration, Socks5Server
-from test_framework.messages import CAddress, hash256
+from test_framework.messages import CAddress, hash256, ser_compact_size
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import check_node_connections, assert_equal, p2p_port
 
@@ -113,7 +113,7 @@ def run_test(self):
         caddr.ip, port_str = ONION_ADDR.split(":")
         caddr.port = int(port_str)
         # TorV3 addrv2 serialization:
-        # time(4) | services(1) | networkID(1) | address length(1) | address(32)
+        # time(4) | services(CompactSize) | networkID(1) | address length(CompactSize) | address(32)
         expected_pubkey = caddr.serialize_v2()[7:39].hex()
 
         # position of services byte of first addr in anchors.dat
@@ -122,7 +122,7 @@ def run_test(self):
         data = bytes()
         with open(node_anchors_path, "rb") as file_handler:
             data = file_handler.read()
-            assert_equal(data[services_index], 0x00)  # services == NONE
+            assert_equal(data[services_index], 0x00)  # services == NONE (CompactSize encoded as 1 byte)
             anchors2 = data.hex()
             assert expected_pubkey in anchors2
 
@@ -131,7 +131,9 @@ def run_test(self):
             # This is necessary because on restart we will not attempt an anchor connection
             # to a host without our required services, even if its address is in the anchors.dat file
             new_data = bytearray(data)[:-32]
-            new_data[services_index] = P2P_SERVICES
+            # Replace the 1-byte services field (0x00) with the CompactSize-encoded P2P_SERVICES (5 bytes for 0x08000009)
+            services_bytes = ser_compact_size(P2P_SERVICES)
+            new_data = new_data[:services_index] + services_bytes + new_data[services_index+1:]
             new_data_hash = hash256(new_data)
             file_handler.write(new_data + new_data_hash)
 
diff --git a/test/functional/interface_bitcoin_cli.py b/test/functional/interface_bitcoin_cli.py
@@ -94,7 +94,7 @@ def test_netinfo(self):
         self.log.info("Test -netinfo local services are moved to header if details are requested")
         det = self.nodes[0].cli('-netinfo', '1').send_cli().splitlines()
         self.log.debug(f"Test -netinfo 1 header output: {det[0]}")
-        assert re.match(rf"^{re.escape(self.config['environment']['CLIENT_NAME'])} client.+services nwl2?$", det[0])
+        assert re.match(rf"^{re.escape(self.config['environment']['CLIENT_NAME'])} client.+services nwl2?4$", det[0])
         assert not any(line.startswith("Local services:") for line in det)
 
     def run_test(self):
diff --git a/test/functional/p2p_addr_relay.py b/test/functional/p2p_addr_relay.py
@@ -11,6 +11,9 @@
 
 from test_framework.messages import (
     CAddress,
+    NODE_REDUCED_DATA,
+    NODE_NETWORK,
+    NODE_WITNESS,
     msg_addr,
     msg_getaddr,
     msg_verack,
@@ -52,7 +55,7 @@ def on_addr(self, message):
             if self.test_addr_contents:
                 # relay_tests checks the content of the addr messages match
                 # expectations based on the message creation in setup_addr_msg
-                assert_equal(addr.nServices, 9)
+                assert_equal(addr.nServices, NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA)
                 if not 8333 <= addr.port < 8343:
                     raise AssertionError("Invalid addr.port of {} (8333-8342 expected)".format(addr.port))
                 assert addr.ip.startswith('123.123.')
diff --git a/test/functional/p2p_addrv2_relay.py b/test/functional/p2p_addrv2_relay.py
@@ -12,6 +12,7 @@
     CAddress,
     msg_addrv2,
     msg_sendaddrv2,
+    ser_compact_size,
 )
 from test_framework.p2p import (
     P2PInterface,
@@ -62,7 +63,7 @@ def calc_addrv2_msg_size(addrs):
     size = 1  # vector length byte
     for addr in addrs:
         size += 4  # time
-        size += 1  # services, COMPACTSIZE(P2P_SERVICES)
+        size += len(ser_compact_size(P2P_SERVICES))  # services, COMPACTSIZE(P2P_SERVICES)
         size += 1  # network id
         size += 1  # address length byte
         size += addr.ADDRV2_ADDRESS_LENGTH[addr.net]  # address
diff --git a/test/functional/p2p_handshake.py b/test/functional/p2p_handshake.py
@@ -11,6 +11,7 @@
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.messages import (
+    NODE_REDUCED_DATA,
     NODE_NETWORK,
     NODE_NETWORK_LIMITED,
     NODE_NONE,
@@ -34,8 +35,8 @@
 # the desirable service flags for pruned peers are dynamic and only apply if
 #  1. the peer's service flag NODE_NETWORK_LIMITED is set *and*
 #  2. the local chain is close to the tip (<24h)
-DESIRABLE_SERVICE_FLAGS_FULL = NODE_NETWORK | NODE_WITNESS
-DESIRABLE_SERVICE_FLAGS_PRUNED = NODE_NETWORK_LIMITED | NODE_WITNESS
+DESIRABLE_SERVICE_FLAGS_FULL = NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA
+DESIRABLE_SERVICE_FLAGS_PRUNED = NODE_NETWORK_LIMITED | NODE_WITNESS | NODE_REDUCED_DATA
 
 
 class P2PHandshakeTest(BitcoinTestFramework):
@@ -98,15 +99,15 @@ def run_test(self):
         self.log.info("Check that lacking desired service flags leads to disconnect (non-pruned peers)")
         self.test_desirable_service_flags(node, [NODE_NONE, NODE_NETWORK, NODE_WITNESS],
                                           DESIRABLE_SERVICE_FLAGS_FULL, expect_disconnect=True)
-        self.test_desirable_service_flags(node, [NODE_NETWORK | NODE_WITNESS],
+        self.test_desirable_service_flags(node, [NODE_NETWORK | NODE_WITNESS | NODE_REDUCED_DATA],
                                           DESIRABLE_SERVICE_FLAGS_FULL, expect_disconnect=False)
 
         self.log.info("Check that limited peers are only desired if the local chain is close to the tip (<24h)")
         self.generate_at_mocktime(int(time.time()) - 25 * 3600)  # tip outside the 24h window, should fail
-        self.test_desirable_service_flags(node, [NODE_NETWORK_LIMITED | NODE_WITNESS],
+        self.test_desirable_service_flags(node, [NODE_NETWORK_LIMITED | NODE_WITNESS | NODE_REDUCED_DATA],
                                           DESIRABLE_SERVICE_FLAGS_FULL, expect_disconnect=True)
         self.generate_at_mocktime(int(time.time()) - 23 * 3600)  # tip inside the 24h window, should succeed
-        self.test_desirable_service_flags(node, [NODE_NETWORK_LIMITED | NODE_WITNESS],
+        self.test_desirable_service_flags(node, [NODE_NETWORK_LIMITED | NODE_WITNESS | NODE_REDUCED_DATA],
                                           DESIRABLE_SERVICE_FLAGS_PRUNED, expect_disconnect=False)
 
         self.log.info("Check that feeler connections get disconnected immediately")
diff --git a/test/functional/p2p_node_network_limited.py b/test/functional/p2p_node_network_limited.py
@@ -11,6 +11,7 @@
 from test_framework.messages import (
     CInv,
     MSG_BLOCK,
+    NODE_REDUCED_DATA,
     NODE_NETWORK_LIMITED,
     NODE_P2P_V2,
     NODE_WITNESS,
@@ -118,7 +119,7 @@ def test_avoid_requesting_historical_blocks(self):
     def run_test(self):
         node = self.nodes[0].add_p2p_connection(P2PIgnoreInv())
 
-        expected_services = NODE_WITNESS | NODE_NETWORK_LIMITED
+        expected_services = NODE_WITNESS | NODE_NETWORK_LIMITED | NODE_REDUCED_DATA
         if self.options.v2transport:
             expected_services |= NODE_P2P_V2
 
diff --git a/test/functional/rpc_net.py b/test/functional/rpc_net.py
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
diff --git a/test/functional/test_framework/p2p.py b/test/functional/test_framework/p2p.py

Original file line number	Diff line number	Diff line change
`@@ -1655,13 +1655,14 @@ bool PeerManagerImpl::HasAllDesirableServiceFlags(ServiceFlags services) const`
`1655`	`1655`
`1656`	`1656`	`ServiceFlags PeerManagerImpl::GetDesirableServiceFlags(ServiceFlags services) const`
`1657`	`1657`	`{`
	`1658`	`+ // We want to preferentially peer with other nodes that enforce UASF-ReducedData, in case of a chain split`
`1658`	`1659`	`if (services & NODE_NETWORK_LIMITED) {`
`1659`	`1660`	`// Limited peers are desirable when we are close to the tip.`
`1660`	`1661`	`if (ApproximateBestBlockDepth() < NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS) {`
`1661`		`- return ServiceFlags(NODE_NETWORK_LIMITED \| NODE_WITNESS);`
	`1662`	`+ return ServiceFlags(NODE_NETWORK_LIMITED \| NODE_WITNESS \| NODE_REDUCED_DATA);`
`1662`	`1663`	`}`
`1663`	`1664`	`}`
`1664`		`- return ServiceFlags(NODE_NETWORK \| NODE_WITNESS);`
	`1665`	`+ return ServiceFlags(NODE_NETWORK \| NODE_WITNESS \| NODE_REDUCED_DATA);`
`1665`	`1666`	`}`
`1666`	`1667`
`1667`	`1668`	`PeerRef PeerManagerImpl::GetPeerRef(NodeId id) const`