Preferentially peer with doublespend-relaying nodes

Tries to maintain 8 outgoing connections and reserves 3/4 of the
incoming connections for nodes that relay doublespends.

src/main.cpp

@@ -4256,6 +4256,25 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
             return false;
         }
 
+        // Disconnect if we have already met our quota of non-doublespend-relaying nodes.
+        if (!(pfrom->nServices & NODE_RELAYS_DOUBLESPENDS))
+        {
+            int nNonDoubleSpendRelaying = 0;
+
+            LOCK(cs_vNodes);
+            BOOST_FOREACH(CNode* pnode, vNodes) {
+                if (!(pnode->nServices & NODE_RELAYS_DOUBLESPENDS))
+                    nNonDoubleSpendRelaying++;
+            }
+
+            if (nNonDoubleSpendRelaying > nMaxConnections / 4) {
+                LogPrint("net", "reached quota of non-doublespend-relaying nodes; disconnecting %s\n",
+                         pfrom->addr.ToString());
+                pfrom->fDisconnect = true;
+                return false;
+            }
+        }
+
         if (pfrom->nVersion == 10300)
             pfrom->nVersion = 300;
         if (!vRecv.empty())

src/net.cpp

@@ -59,7 +59,10 @@
 using namespace std;
 
 namespace {
-    const int MAX_OUTBOUND_CONNECTIONS = 8;
+    const int MAX_STD_OUTBOUND_CONNECTIONS = 8;
+    const int MIN_REPLACE_BY_FEE_OUTBOUND_CONNECTIONS = 8;
+
+    const int MAX_OUTBOUND_CONNECTIONS = MAX_STD_OUTBOUND_CONNECTIONS + MIN_REPLACE_BY_FEE_OUTBOUND_CONNECTIONS;
 
     struct ListenSocket {
         SOCKET socket;
@@ -1555,13 +1558,17 @@ void ThreadOpenConnections()
         // Only connect out to one peer per network group (/16 for IPv4).
         // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
         int nOutbound = 0;
+        int nDoubleSpendRelayingOutbound = 0;
         set<vector<unsigned char> > setConnected;
         {
             LOCK(cs_vNodes);
             BOOST_FOREACH(CNode* pnode, vNodes) {
                 if (!pnode->fInbound) {
                     setConnected.insert(pnode->addr.GetGroup());
                     nOutbound++;
+
+                    if (pnode->nServices & NODE_RELAYS_DOUBLESPENDS)
+                        nDoubleSpendRelayingOutbound++;
                 }
             }
         }
@@ -1595,6 +1602,21 @@ void ThreadOpenConnections()
             if (addr.GetPort() != Params().GetDefaultPort() && nTries < 50)
                 continue;
 
+            // Reserve some outbound connections for nodes that relay
+            // double-spends.
+            //
+            // Unfortunately nServices seems to end up corrupted at times,
+            // leading us to adding more nodes than expected, so this is a more
+            // strict test than might otherwise be expected.
+            //
+            // Also, we'll still end up with too many at times, because we'll
+            // find out afterwords that what we thought was a node's nServices
+            // was incorrect; Bitcoin Core will even stay connected to nodes
+            // not advertising NODE_NETWORK in this case.
+            if (!((addr.nServices & NODE_RELAYS_DOUBLESPENDS) && (addr.nServices & ~NODE_RELAYS_DOUBLESPENDS) == NODE_NETWORK)
+                    && (nOutbound - nDoubleSpendRelayingOutbound >= MAX_STD_OUTBOUND_CONNECTIONS))
+                continue;
+
             addrConnect = addr;
             break;
         }

src/protocol.h

@@ -230,6 +230,7 @@ enum {
     // set by all Bitcoin Core nodes, and is unset by SPV clients or other peers that just want
     // network services but don't provide them.
     NODE_NETWORK = (1 << 0),
+
     // NODE_GETUTXO means the node is capable of responding to the getutxo protocol request.
     // Bitcoin Core does not support this but a patch set called Bitcoin XT does.
     // See BIP 64 for details on how this is implemented.
@@ -250,6 +251,8 @@ enum {
     NODE_REPLACE_BY_FEE = (1 << 26),
 };
 
+const uint64_t NODE_RELAYS_DOUBLESPENDS = NODE_REPLACE_BY_FEE;
+
 /** A CService with information about it as peer */
 class CAddress : public CService
 {