Port Libre Relay to v29.0

All changes from v28.1..libre-relay-v28.1-2, minus the docker/github CI
stuff.

Author: petertodd

src/bitcoin-cli.cpp

@@ -395,6 +395,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
 private:
     std::array<std::array<uint16_t, NETWORKS.size() + 1>, 3> m_counts{{{}}}; //!< Peer counts by (in/out/total, networks/total)
     uint8_t m_block_relay_peers_count{0};
+    uint8_t m_libre_peers_count{0};
     uint8_t m_manual_peers_count{0};
     int8_t NetworkStringToId(const std::string& str) const
     {
@@ -470,6 +471,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
         if (conn_type == "block-relay-only") return "block";
         if (conn_type == "manual" || conn_type == "feeler") return conn_type;
         if (conn_type == "addr-fetch") return "addr";
+        if (conn_type == "libre") return "libre";
         return "";
     }
     std::string FormatServices(const UniValue& services)
@@ -536,6 +538,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
             ++m_counts.at(2).at(network_id);                // total by network
             ++m_counts.at(2).at(NETWORKS.size());           // total overall
             if (conn_type == "block-relay-only") ++m_block_relay_peers_count;
+            if (conn_type == "libre") ++m_libre_peers_count;
             if (conn_type == "manual") ++m_manual_peers_count;
             if (m_outbound_only_selected && !is_outbound) continue;
             if (DetailsRequested()) {
@@ -577,7 +580,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
         // Report detailed peer connections list sorted by direction and minimum ping time.
         if (DetailsRequested() && !m_peers.empty()) {
             std::sort(m_peers.begin(), m_peers.end());
-            result += strprintf("<->   type   net %*s  v  mping   ping send recv  txn  blk  hb %*s%*s%*s ",
+            result += strprintf("<->     type   net %*s  v  mping   ping send recv  txn  blk  hb %*s%*s%*s ",
                                 m_max_services_length, "serv",
                                 m_max_addr_processed_length, "addrp",
                                 m_max_addr_rate_limited_length, "addrl",
@@ -587,7 +590,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
             for (const Peer& peer : m_peers) {
                 std::string version{ToString(peer.version) + peer.sub_version};
                 result += strprintf(
-                    "%3s %6s %5s %*s %2s%7s%7s%5s%5s%5s%5s  %2s %*s%*s%*s%*i %*s %-*s%s\n",
+                    "%3s %8s %5s %*s %2s%7s%7s%5s%5s%5s%5s  %2s %*s%*s%*s%*i %*s %-*s%s\n",
                     peer.is_outbound ? "out" : "in",
                     ConnectionTypeForNetinfo(peer.conn_type),
                     peer.network,
@@ -615,7 +618,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
                     IsAddressSelected() ? peer.addr : "",
                     IsVersionSelected() && version != "0" ? version : "");
             }
-            result += strprintf("                %*s         ms     ms  sec  sec  min  min                %*s\n\n", m_max_services_length, "", m_max_age_length, "min");
+            result += strprintf("                %*s           ms     ms  sec  sec  min  min                %*s\n\n", m_max_services_length, "", m_max_age_length, "min");
         }
 
         // Report peer connection totals by type.
@@ -638,6 +641,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
         }
 
         result += "   total   block";
+        if (m_libre_peers_count) result += "   libre";
         if (m_manual_peers_count) result += "  manual";
 
         const std::array rows{"in", "out", "total"};
@@ -649,6 +653,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
             result += strprintf("   %5i", m_counts.at(i).at(NETWORKS.size())); // total peers count
             if (i == 1) { // the outbound row has two extra columns for block relay and manual peer counts
                 result += strprintf("   %5i", m_block_relay_peers_count);
+                if (m_libre_peers_count) result += strprintf("   %5i", m_libre_peers_count);
                 if (m_manual_peers_count) result += strprintf("   %5i", m_manual_peers_count);
             }
         }
@@ -705,6 +710,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
         "           \"manual\" - peer we manually added using RPC addnode or the -addnode/-connect config options\n"
         "           \"feeler\" - short-lived connection for testing addresses\n"
         "           \"addr\"   - address fetch; short-lived connection for requesting addresses\n"
+        "           \"libre\"  - libre relay; long-lived connection for libre transaction-relay\n"
         "  net      Network the peer connected through (\"ipv4\", \"ipv6\", \"onion\", \"i2p\", \"cjdns\", or \"npr\" (not publicly routable))\n"
         "  serv     Services offered by the peer\n"
         "           \"n\" - NETWORK: peer can serve the full block chain\n"

src/init.cpp

@@ -837,7 +837,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_LIBRE_RELAY);
 int64_t peer_connect_timeout;
 std::set<BlockFilterType> g_enabled_filter_types;
 
@@ -1905,6 +1905,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     CConnman::Options connOptions;
     connOptions.m_local_services = g_local_services;
     connOptions.m_max_automatic_connections = nMaxConnections;
+    connOptions.m_max_outbound_libre_relay = MAX_LIBRE_RELAY_CONNECTIONS;
     connOptions.uiInterface = &uiInterface;
     connOptions.m_banman = node.banman.get();
     connOptions.m_msgproc = node.peerman.get();

src/net.cpp

@@ -1875,6 +1875,9 @@ bool CConnman::AddConnection(const std::string& address, ConnectionType conn_typ
     case ConnectionType::BLOCK_RELAY:
         max_connections = m_max_outbound_block_relay;
         break;
+    case ConnectionType::LIBRE_RELAY:
+        max_connections = m_max_outbound_libre_relay;
+        break;
     // no limit for ADDR_FETCH because -seednode has no limit either
     case ConnectionType::ADDR_FETCH:
         break;
@@ -2633,6 +2636,7 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, Spa
         // Only connect out to one peer per ipv4/ipv6 network group (/16 for IPv4).
         int nOutboundFullRelay = 0;
         int nOutboundBlockRelay = 0;
+        int nOutboundLibreRelay = 0;
         int outbound_privacy_network_peers = 0;
         std::set<std::vector<unsigned char>> outbound_ipv46_peer_netgroups;
 
@@ -2641,6 +2645,7 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, Spa
             for (const CNode* pnode : m_nodes) {
                 if (pnode->IsFullOutboundConn()) nOutboundFullRelay++;
                 if (pnode->IsBlockOnlyConn()) nOutboundBlockRelay++;
+                if (pnode->IsLibreRelay()) nOutboundLibreRelay++;
 
                 // Make sure our persistent outbound slots to ipv4/ipv6 peers belong to different netgroups.
                 switch (pnode->m_conn_type) {
@@ -2656,6 +2661,7 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, Spa
                     case ConnectionType::MANUAL:
                     case ConnectionType::OUTBOUND_FULL_RELAY:
                     case ConnectionType::BLOCK_RELAY:
+                    case ConnectionType::LIBRE_RELAY:
                         const CAddress address{pnode->addr};
                         if (address.IsTor() || address.IsI2P() || address.IsCJDNS()) {
                             // Since our addrman-groups for these networks are
@@ -2684,6 +2690,7 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, Spa
         auto now = GetTime<std::chrono::microseconds>();
         bool anchor = false;
         bool fFeeler = false;
+        bool libre = false;
         std::optional<Network> preferred_net;
 
         // Determine what type of connection to open. Opening
@@ -2730,6 +2737,9 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, Spa
             // (similar to how we deal with extra outbound peers).
             next_extra_block_relay = now + rng.rand_exp_duration(EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
             conn_type = ConnectionType::BLOCK_RELAY;
+        } else if (nOutboundLibreRelay < m_max_outbound_libre_relay) {
+            conn_type = ConnectionType::LIBRE_RELAY;
+            libre = true;
         } else if (now > next_feeler) {
             next_feeler = now + rng.rand_exp_duration(FEELER_INTERVAL);
             conn_type = ConnectionType::FEELER;
@@ -2827,6 +2837,11 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, Spa
                 continue;
             }
 
+            // if we would like to open a libre connection, requires
+            // the libre service flag to be set
+            if (libre && !HasLibreRelayServiceFlag(addr.nServices))
+                continue;
+
             // for non-feelers, require all the services we'll want,
             // for feelers, only require they be a full node (only because most
             // SPV clients don't have a good address DB available)

src/net.h

@@ -65,6 +65,8 @@ static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 4 * 1000 * 1000;
 static const unsigned int MAX_SUBVERSION_LENGTH = 256;
 /** Maximum number of automatic outgoing nodes over which we'll relay everything (blocks, tx, addrs, etc) */
 static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS = 8;
+/** Maximum number of automatic libre-relay peers */
+static const int MAX_LIBRE_RELAY_CONNECTIONS = 4;
 /** Maximum number of addnode outgoing nodes */
 static const int MAX_ADDNODE_CONNECTIONS = 8;
 /** Maximum number of block-relay-only outgoing connections */
@@ -761,6 +763,7 @@ class CNode
         switch (m_conn_type) {
             case ConnectionType::OUTBOUND_FULL_RELAY:
             case ConnectionType::BLOCK_RELAY:
+            case ConnectionType::LIBRE_RELAY:
                 return true;
             case ConnectionType::INBOUND:
             case ConnectionType::MANUAL:
@@ -789,6 +792,7 @@ class CNode
         case ConnectionType::ADDR_FETCH:
                 return false;
         case ConnectionType::OUTBOUND_FULL_RELAY:
+        case ConnectionType::LIBRE_RELAY:
         case ConnectionType::MANUAL:
                 return true;
         } // no default case, so the compiler can warn about missing cases
@@ -812,6 +816,10 @@ class CNode
         return m_conn_type == ConnectionType::INBOUND;
     }
 
+    bool IsLibreRelay() const {
+        return m_conn_type == ConnectionType::LIBRE_RELAY;
+    }
+
     bool ExpectServicesFromConn() const {
         switch (m_conn_type) {
             case ConnectionType::INBOUND:
@@ -821,6 +829,7 @@ class CNode
             case ConnectionType::OUTBOUND_FULL_RELAY:
             case ConnectionType::BLOCK_RELAY:
             case ConnectionType::ADDR_FETCH:
+            case ConnectionType::LIBRE_RELAY:
                 return true;
         } // no default case, so the compiler can warn about missing cases
 
@@ -1078,6 +1087,7 @@ class CConnman
         bool m_i2p_accept_incoming;
         bool whitelist_forcerelay = DEFAULT_WHITELISTFORCERELAY;
         bool whitelist_relay = DEFAULT_WHITELISTRELAY;
+        int m_max_outbound_libre_relay = 0;
     };
 
     void Init(const Options& connOptions) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_total_bytes_sent_mutex)
@@ -1088,7 +1098,8 @@ class CConnman
         m_max_automatic_connections = connOptions.m_max_automatic_connections;
         m_max_outbound_full_relay = std::min(MAX_OUTBOUND_FULL_RELAY_CONNECTIONS, m_max_automatic_connections);
         m_max_outbound_block_relay = std::min(MAX_BLOCK_RELAY_ONLY_CONNECTIONS, m_max_automatic_connections - m_max_outbound_full_relay);
-        m_max_automatic_outbound = m_max_outbound_full_relay + m_max_outbound_block_relay + m_max_feeler;
+        m_max_outbound_libre_relay = connOptions.m_max_outbound_libre_relay;
+        m_max_automatic_outbound = m_max_outbound_full_relay + m_max_outbound_block_relay + m_max_feeler + m_max_outbound_libre_relay;
         m_max_inbound = std::max(0, m_max_automatic_connections - m_max_automatic_outbound);
         m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing;
         m_client_interface = connOptions.uiInterface;
@@ -1524,6 +1535,8 @@ class CConnman
     /** Pointer to this node's banman. May be nullptr - check existence before dereferencing. */
     BanMan* m_banman;
 
+    int m_max_outbound_libre_relay;
+
     /**
      * Addresses that were saved during the previous clean shutdown. We'll
      * attempt to make block-relay-only connections to them.

src/net_processing.cpp

@@ -3420,6 +3420,13 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
             return;
         }
 
+        if (pfrom.IsLibreRelay() && !HasLibreRelayServiceFlag(nServices))
+        {
+            LogDebug(BCLog::NET, "peer=%d does not offer libre relay as expected; disconnecting\n", pfrom.GetId());
+            pfrom.fDisconnect = true;
+            return;
+        }
+
         if (nVersion < MIN_PEER_PROTO_VERSION) {
             // disconnect from peers older than this proto version
             LogDebug(BCLog::NET, "peer using obsolete version %i, %s\n", nVersion, pfrom.DisconnectMsg(fLogIPs));

src/node/connection_types.cpp

@@ -20,6 +20,8 @@ std::string ConnectionTypeAsString(ConnectionType conn_type)
         return "block-relay-only";
     case ConnectionType::ADDR_FETCH:
         return "addr-fetch";
+    case ConnectionType::LIBRE_RELAY:
+        return "libre";
     } // no default case, so the compiler can warn about missing cases
 
     assert(false);

src/node/connection_types.h

@@ -75,6 +75,12 @@ enum class ConnectionType {
      * AddrMan is empty.
      */
     ADDR_FETCH,
+
+    /**
+     * Libre-relay connections are long-lived connections used to relay transactions
+     * with peers accepting the libre standardness policies.
+     */
+    LIBRE_RELAY,
 };
 
 /** Convert ConnectionType enum to a string value */

src/node/mempool_args.cpp

@@ -81,11 +81,12 @@ util::Result<void> ApplyArgsManOptions(const ArgsManager& argsman, const CChainP
 
     mempool_opts.permit_bare_multisig = argsman.GetBoolArg("-permitbaremultisig", DEFAULT_PERMIT_BAREMULTISIG);
 
-    if (argsman.GetBoolArg("-datacarrier", DEFAULT_ACCEPT_DATACARRIER)) {
-        mempool_opts.max_datacarrier_bytes = argsman.GetIntArg("-datacarriersize", MAX_OP_RETURN_RELAY);
-    } else {
-        mempool_opts.max_datacarrier_bytes = std::nullopt;
-    }
+    // if (argsman.GetBoolArg("-datacarrier", DEFAULT_ACCEPT_DATACARRIER)) {
+    //     mempool_opts.max_datacarrier_bytes = argsman.GetIntArg("-datacarriersize", MAX_OP_RETURN_RELAY);
+    // } else {
+    //     mempool_opts.max_datacarrier_bytes = std::nullopt;
+    // }
+    mempool_opts.max_datacarrier_bytes = MAX_OP_RETURN_RELAY;
 
     mempool_opts.require_standard = !argsman.GetBoolArg("-acceptnonstdtxn", DEFAULT_ACCEPT_NON_STD_TXN);
     if (!chainparams.IsTestChain() && !mempool_opts.require_standard) {

src/policy/feerate.h

@@ -72,6 +72,10 @@ class CFeeRate
     friend CFeeRate operator*(const CFeeRate& f, int a) { return CFeeRate(a * f.nSatoshisPerK); }
     friend CFeeRate operator*(int a, const CFeeRate& f) { return CFeeRate(a * f.nSatoshisPerK); }
 
+    // For RBFR. A bit of a hack to have this. But does the job.
+    friend CFeeRate operator*(const CFeeRate& f, double a) { return CFeeRate(int(a * f.nSatoshisPerK)); }
+    friend CFeeRate operator*(double a, const CFeeRate& f) { return CFeeRate(int(a * f.nSatoshisPerK)); }
+
     SERIALIZE_METHODS(CFeeRate, obj) { READWRITE(obj.nSatoshisPerK); }
 };
 

src/policy/policy.cpp

@@ -137,17 +137,17 @@ bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_dat
         }
     }
 
-    unsigned int nDataOut = 0;
+    //unsigned int nDataOut = 0;
     TxoutType whichType;
     for (const CTxOut& txout : tx.vout) {
         if (!::IsStandard(txout.scriptPubKey, max_datacarrier_bytes, whichType)) {
             reason = "scriptpubkey";
             return false;
         }
 
-        if (whichType == TxoutType::NULL_DATA)
-            nDataOut++;
-        else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
+        if (whichType == TxoutType::NULL_DATA) {
+            // nDataOut++;
+        } else if ((whichType == TxoutType::MULTISIG) && (!permit_bare_multisig)) {
             reason = "bare-multisig";
             return false;
         }
@@ -160,10 +160,10 @@ bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_dat
     }
 
     // only one OP_RETURN txout is permitted
-    if (nDataOut > 1) {
-        reason = "multi-op-return";
-        return false;
-    }
+    //if (nDataOut > 1) {
+    //    reason = "multi-op-return";
+    //    return false;
+    //}
 
     return true;
 }