1751        for (const auto& stale_tx : stale_txs) {
1752            // Only hold lock per single submission
1753            LOCK(cs_main);
1754            auto mempool_acceptable = m_chainman.ProcessTransaction(stale_tx, /*test_accept=*/true);
1755            if (mempool_acceptable.m_result_type == MempoolAcceptResult::ResultType::VALID) {
1756                if (!m_tx_for_private_broadcast.TryGrantRetry(stale_tx)) continue;
1757                LogDebug(BCLog::PRIVBROADCAST,
1758                         "Reattempting broadcast of stale txid=%s wtxid=%s",
1759                         stale_tx->GetHash().ToString(), stale_tx->GetWitnessHash().ToString());
1760                ++num_for_rebroadcast;
1761            } else {
1762                LogDebug(BCLog::PRIVBROADCAST, "Giving up broadcast attempts for txid=%s wtxid=%s: %s",
1763                         stale_tx->GetHash().ToString(), stale_tx->GetWitnessHash().ToString(),
1764                         mempool_acceptable.m_state.ToString());
1765                m_tx_for_private_broadcast.MarkResolved(stale_tx);
1766            }
1767        }
1768
1769        // This could overshoot, but that is ok - we will open some private connections in vain.
1770        m_connman.m_private_broadcast.NumToOpenAdd(num_for_rebroadcast);
1771    }
1772
1773    const auto delta{2min + FastRandomContext().randrange<std::chrono::milliseconds>(1min)};
1774    scheduler.scheduleFromNow([&] { ReattemptPrivateBroadcast(scheduler); }, delta);
1775}
1776
1777void PeerManagerImpl::FinalizeNode(const CNode& node)
1778{
1779    NodeId nodeid = node.GetId();
1780    {
1781    LOCK(cs_main);
1782    {
1783        // We remove the PeerRef from g_peer_map here, but we don't always
1784        // destruct the Peer. Sometimes another thread is still holding a
1785        // PeerRef, so the refcount is >= 1. Be careful not to do any
1786        // processing here that assumes Peer won't be changed before it's
1787        // destructed.
1788        PeerRef peer = RemovePeer(nodeid);
1789        assert(peer != nullptr);
1790        m_wtxid_relay_peers -= peer->m_wtxid_relay;
1791        assert(m_wtxid_relay_peers >= 0);
1792    }
1793    CNodeState *state = State(nodeid);
1794    assert(state != nullptr);
1795
1796    if (state->fSyncStarted)
1797        nSyncStarted--;
1798
1799    for (const QueuedBlock& entry : state->vBlocksInFlight) {
1800        auto range = mapBlocksInFlight.equal_range(entry.pindex->GetBlockHash());
1801        while (range.first != range.second) {
1802            auto [node_id, list_it] = range.first->second;
1803            if (node_id != nodeid) {
1804                range.first++;
1805            } else {
1806                range.first = mapBlocksInFlight.erase(range.first);
1807            }
1808        }
1809    }
1810    {
1811        LOCK(m_tx_download_mutex);
1812        m_txdownloadman.DisconnectedPeer(nodeid);
1813    }
1814    if (m_txreconciliation) m_txreconciliation->ForgetPeer(nodeid);
1815    m_num_preferred_download_peers -= state->fPreferredDownload;
1816    m_peers_downloading_from -= (!state->vBlocksInFlight.empty());
1817    assert(m_peers_downloading_from >= 0);
1818    m_outbound_peers_with_protect_from_disconnect -= state->m_chain_sync.m_protect;
1819    assert(m_outbound_peers_with_protect_from_disconnect >= 0);
1820
1821    m_node_states.erase(nodeid);
1822
1823    if (m_node_states.empty()) {
1824        // Do a consistency check after the last peer is removed.
1825        assert(mapBlocksInFlight.empty());
1826        assert(m_num_preferred_download_peers == 0);
1827        assert(m_peers_downloading_from == 0);
1828        assert(m_outbound_peers_with_protect_from_disconnect == 0);
1829        assert(m_wtxid_relay_peers == 0);
1830        WITH_LOCK(m_tx_download_mutex, m_txdownloadman.CheckIsEmpty());
1831    }
1832    } // cs_main
1833    if (node.fSuccessfullyConnected &&
1834        !node.IsBlockOnlyConn() && !node.IsPrivateBroadcastConn() && !node.IsInboundConn()) {
1835        // Only change visible addrman state for full outbound peers.  We don't
1836        // call Connected() for feeler connections since they don't have
1837        // fSuccessfullyConnected set. Also don't call Connected() for private broadcast
1838        // connections since they could leak information in addrman.
1839        m_addrman.Connected(node.addr);
1840    }
1841    {
1842        LOCK(m_headers_presync_mutex);
1843        m_headers_presync_stats.erase(nodeid);
1844    }
1845    if (node.IsPrivateBroadcastConn()) {
1846        m_tx_for_private_broadcast.NodeDisconnected(nodeid);
1847        // We consider a transaction sent to a peer if we sent them an INV.
1848        // Normally they should request the transaction with GETDATA, but this may
1849        // not happen if they are already aware of the transaction.
1850        // If we didn't send them an INV, schedule a new connection to compensate
1851        // for this send failure. Whether we sent them an INV is not readily
1852        // available here, so use fSuccessfullyConnected because INV is sent right
1853        // after a successful handshake when there is a pending transaction.
1854        if (!node.fSuccessfullyConnected && m_tx_for_private_broadcast.HavePendingTransactions()) {
1855            m_connman.m_private_broadcast.NumToOpenAdd(1);
1856        }
1857    }
1858    LogDebug(BCLog::NET, "Cleared nodestate for peer=%d\n", nodeid);
1859}
1860
1861bool PeerManagerImpl::HasAllDesirableServiceFlags(ServiceFlags services) const
1862{
1863    // Shortcut for (services & GetDesirableServiceFlags(services)) == GetDesirableServiceFlags(services)
1864    return !(GetDesirableServiceFlags(services) & (~services));
1865}
1866
1867ServiceFlags PeerManagerImpl::GetDesirableServiceFlags(ServiceFlags services) const
1868{
1869    if (services & NODE_NETWORK_LIMITED) {
1870        // Limited peers are desirable when we are close to the tip.
1871        if (ApproximateBestBlockDepth() < NODE_NETWORK_LIMITED_ALLOW_CONN_BLOCKS) {
1872            return ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
1873        }
1874    }
1875    return ServiceFlags(NODE_NETWORK | NODE_WITNESS);
1876}
1877
1878PeerRef PeerManagerImpl::GetPeerRef(NodeId id) const
1879{
1880    LOCK(m_peer_mutex);
1881    auto it = m_peer_map.find(id);
1882    return it != m_peer_map.end() ? it->second : nullptr;
1883}
1884
1885PeerRef PeerManagerImpl::RemovePeer(NodeId id)
1886{
1887    PeerRef ret;
1888    LOCK(m_peer_mutex);
1889    auto it = m_peer_map.find(id);
1890    if (it != m_peer_map.end()) {
1891        ret = std::move(it->second);
1892        m_peer_map.erase(it);
1893    }
1894    return ret;
1895}
1896
1897std::vector<PeerRef> PeerManagerImpl::GetAllPeers() const
1898{
1899    std::vector<PeerRef> peers;
1900    LOCK(m_peer_mutex);
1901    peers.reserve(m_peer_map.size());
1902    for (const auto& [_, peer] : m_peer_map) {
1903        peers.push_back(peer);
1904    }
1905    return peers;
1906}
1907
1908bool PeerManagerImpl::GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const
1909{
1910    {
1911        LOCK(cs_main);
1912        const CNodeState* state = State(nodeid);
1913        if (state == nullptr)
1914            return false;
1915        stats.nSyncHeight = state->pindexBestKnownBlock ? state->pindexBestKnownBlock->nHeight : -1;
1916        stats.nCommonHeight = state->pindexLastCommonBlock ? state->pindexLastCommonBlock->nHeight : -1;
1917        for (const QueuedBlock& queue : state->vBlocksInFlight) {
1918            if (queue.pindex)
1919                stats.vHeightInFlight.push_back(queue.pindex->nHeight);
1920        }
1921    }
1922
1923    PeerRef peer = GetPeerRef(nodeid);
1924    if (peer == nullptr) return false;
1925    stats.their_services = peer->m_their_services;
1926    // It is common for nodes with good ping times to suddenly become lagged,
1927    // due to a new block arriving or other large transfer.
1928    // Merely reporting pingtime might fool the caller into thinking the node was still responsive,
1929    // since pingtime does not update until the ping is complete, which might take a while.
1930    // So, if a ping is taking an unusually long time in flight,
1931    // the caller can immediately detect that this is happening.
1932    NodeClock::duration ping_wait{0us};
1933    if ((0 != peer->m_ping_nonce_sent) && (peer->m_ping_start.load() > NodeClock::epoch)) {
1934        ping_wait = NodeClock::now() - peer->m_ping_start.load();
1935    }
1936
1937    if (auto tx_relay = peer->GetTxRelay(); tx_relay != nullptr) {
1938        stats.m_relay_txs = WITH_LOCK(tx_relay->m_bloom_filter_mutex, return tx_relay->m_relay_txs);
1939        stats.m_fee_filter_received = tx_relay->m_fee_filter_received.load();
1940        LOCK(tx_relay->m_tx_inventory_mutex);
1941        stats.m_last_inv_seq = tx_relay->m_last_inv_sequence;
1942        stats.m_inv_to_send = tx_relay->m_tx_inventory_to_send.size();
1943    } else {
1944        stats.m_relay_txs = false;
1945        stats.m_fee_filter_received = 0;
1946        stats.m_inv_to_send = 0;
1947    }
1948
1949    stats.m_ping_wait = ping_wait;
1950    stats.m_addr_processed = peer->m_addr_processed.load();
1951    stats.m_addr_rate_limited = peer->m_addr_rate_limited.load();
1952    stats.m_addr_relay_enabled = peer->m_addr_relay_enabled.load();
1953    {
1954        LOCK(peer->m_headers_sync_mutex);
1955        if (peer->m_headers_sync) {
1956            stats.presync_height = peer->m_headers_sync->GetPresyncHeight();
1957        }
1958    }
1959    stats.time_offset = peer->m_time_offset;
1960
1961    return true;
1962}
1963
1964std::vector<node::TxOrphanage::OrphanInfo> PeerManagerImpl::GetOrphanTransactions()
1965{
1966    LOCK(m_tx_download_mutex);
1967    return m_txdownloadman.GetOrphanTransactions();
1968}
1969
1970PeerManagerInfo PeerManagerImpl::GetInfo() const
1971{
1972    LOCK(m_inv_to_send_mutex);
1973    return PeerManagerInfo{
1974        .median_outbound_time_offset = m_outbound_time_offsets.Median(),
1975        .ignores_incoming_txs = m_opts.ignore_incoming_txs,
1976        .private_broadcast = m_opts.private_broadcast,
1977        .tx_send_rate = m_opts.tx_send_rate,
1978        .inbound_bucket = m_inbound_inv_bucket.info(),
1979        .outbound_bucket = m_outbound_inv_bucket.info(),
1980    };
1981}
1982
1983std::vector<PrivateBroadcast::TxBroadcastInfo> PeerManagerImpl::GetPrivateBroadcastInfo() const
1984{
1985    return m_tx_for_private_broadcast.GetBroadcastInfo();
1986}
1987
1988std::vector<CTransactionRef> PeerManagerImpl::AbortPrivateBroadcast(const uint256& id)
1989{
1990    const auto snapshot{m_tx_for_private_broadcast.GetBroadcastInfo()};
1991    std::vector<CTransactionRef> removed_txs;
1992
1993    size_t connections_cancelled{0};
1994    for (const auto& tx_info : snapshot) {
1995        const CTransactionRef& tx{tx_info.tx};
1996        if (tx->GetHash().ToUint256() != id && tx->GetWitnessHash().ToUint256() != id) continue;
1997        if (const auto remaining_sends{m_tx_for_private_broadcast.Remove(tx)}) {
1998            removed_txs.push_back(tx);
1999            connections_cancelled += *remaining_sends;
2000        }