1251/** Whether this peer can serve us blocks. */
1252static bool CanServeBlocks(const Peer& peer)
1253{
1254    return peer.m_their_services & (NODE_NETWORK|NODE_NETWORK_LIMITED);
1255}
1256
1257/** Whether this peer can only serve limited recent blocks (e.g. because
1258 *  it prunes old blocks) */
1259static bool IsLimitedPeer(const Peer& peer)
1260{
1261    return (!(peer.m_their_services & NODE_NETWORK) &&
1262             (peer.m_their_services & NODE_NETWORK_LIMITED));
1263}
1264
1265/** Whether this peer can serve us witness data */
1266static bool CanServeWitnesses(const Peer& peer)
1267{
1268    return peer.m_their_services & NODE_WITNESS;
1269}
1270
1271std::chrono::microseconds PeerManagerImpl::NextInvToInbounds(std::chrono::microseconds now,
1272                                                             std::chrono::seconds average_interval,
1273                                                             uint64_t network_key)
1274{
1275    auto [it, inserted] = m_next_inv_to_inbounds_per_network_key.try_emplace(network_key, 0us);
1276    auto& timer{it->second};
1277    if (timer < now) {
1278        timer = now + m_rng.rand_exp_duration(average_interval);
1279    }
1280    return timer;
1281}
1282
1283bool PeerManagerImpl::IsBlockRequested(const uint256& hash)
1284{
1285    return mapBlocksInFlight.contains(hash);
1286}
1287
1288bool PeerManagerImpl::IsBlockRequestedFromOutbound(const uint256& hash)
1289{
1290    for (auto range = mapBlocksInFlight.equal_range(hash); range.first != range.second; range.first++) {
1291        auto [nodeid, block_it] = range.first->second;
1292        PeerRef peer{GetPeerRef(nodeid)};
1293        if (peer && !peer->m_is_inbound) return true;
1294    }
1295
1296    return false;
1297}
1298
1299void PeerManagerImpl::RemoveBlockRequest(const uint256& hash, std::optional<NodeId> from_peer)
1300{
1301    auto range = mapBlocksInFlight.equal_range(hash);
1302    if (range.first == range.second) {
1303        // Block was not requested from any peer
1304        return;
1305    }
1306
1307    // We should not have requested too many of this block
1308    Assume(mapBlocksInFlight.count(hash) <= MAX_CMPCTBLOCKS_INFLIGHT_PER_BLOCK);
1309
1310    while (range.first != range.second) {
1311        const auto& [node_id, list_it]{range.first->second};
1312
1313        if (from_peer && *from_peer != node_id) {
1314            range.first++;
1315            continue;
1316        }
1317
1318        CNodeState& state = *Assert(State(node_id));
1319
1320        if (state.vBlocksInFlight.begin() == list_it) {
1321            // First block on the queue was received, update the start download time for the next one
1322            state.m_downloading_since = std::max(state.m_downloading_since, GetTime<std::chrono::microseconds>());
1323        }
1324        state.vBlocksInFlight.erase(list_it);
1325
1326        if (state.vBlocksInFlight.empty()) {
1327            // Last validated block on the queue for this peer was received.
1328            m_peers_downloading_from--;
1329        }
1330        state.m_stalling_since = 0us;
1331
1332        range.first = mapBlocksInFlight.erase(range.first);
1333    }
1334}
1335
1336bool PeerManagerImpl::BlockRequested(NodeId nodeid, const CBlockIndex& block, std::list<QueuedBlock>::iterator** pit)
1337{
1338    const uint256& hash{block.GetBlockHash()};
1339
1340    CNodeState *state = State(nodeid);
1341    assert(state != nullptr);
1342
1343    Assume(mapBlocksInFlight.count(hash) <= MAX_CMPCTBLOCKS_INFLIGHT_PER_BLOCK);
1344
1345    // Short-circuit most stuff in case it is from the same node
1346    for (auto range = mapBlocksInFlight.equal_range(hash); range.first != range.second; range.first++) {
1347        if (range.first->second.first == nodeid) {
1348            if (pit) {
1349                *pit = &range.first->second.second;
1350            }
1351            return false;
1352        }
1353    }
1354
1355    // Make sure it's not being fetched already from same peer.
1356    RemoveBlockRequest(hash, nodeid);
1357
1358    std::list<QueuedBlock>::iterator it = state->vBlocksInFlight.insert(state->vBlocksInFlight.end(),
1359            {&block, std::unique_ptr<PartiallyDownloadedBlock>(pit ? new PartiallyDownloadedBlock(&m_mempool) : nullptr)});
1360    if (state->vBlocksInFlight.size() == 1) {
1361        // We're starting a block download (batch) from this peer.
1362        state->m_downloading_since = GetTime<std::chrono::microseconds>();
1363        m_peers_downloading_from++;
1364    }
1365    auto itInFlight = mapBlocksInFlight.insert(std::make_pair(hash, std::make_pair(nodeid, it)));
1366    if (pit) {
1367        *pit = &itInFlight->second.second;
1368    }
1369    return true;
1370}
1371
1372void PeerManagerImpl::MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid)
1373{
1374    AssertLockHeld(cs_main);
1375
1376    // When in -blocksonly mode, never request high-bandwidth mode from peers. Our
1377    // mempool will not contain the transactions necessary to reconstruct the
1378    // compact block.
1379    if (m_opts.ignore_incoming_txs) return;
1380
1381    CNodeState* nodestate = State(nodeid);
1382    PeerRef peer{GetPeerRef(nodeid)};
1383    if (!nodestate || !nodestate->m_provides_cmpctblocks) {
1384        // Don't request compact blocks if the peer has not signalled support
1385        return;
1386    }
1387
1388    int num_outbound_hb_peers = 0;
1389    for (std::list<NodeId>::iterator it = lNodesAnnouncingHeaderAndIDs.begin(); it != lNodesAnnouncingHeaderAndIDs.end(); it++) {
1390        if (*it == nodeid) {
1391            lNodesAnnouncingHeaderAndIDs.erase(it);
1392            lNodesAnnouncingHeaderAndIDs.push_back(nodeid);
1393            return;
1394        }
1395        PeerRef peer_ref{GetPeerRef(*it)};
1396        if (peer_ref && !peer_ref->m_is_inbound) ++num_outbound_hb_peers;
1397    }
1398    if (peer && peer->m_is_inbound) {
1399        // If we're adding an inbound HB peer, make sure we're not removing
1400        // our last outbound HB peer in the process.
1401        if (lNodesAnnouncingHeaderAndIDs.size() >= 3 && num_outbound_hb_peers == 1) {
1402            PeerRef remove_peer{GetPeerRef(lNodesAnnouncingHeaderAndIDs.front())};
1403            if (remove_peer && !remove_peer->m_is_inbound) {
1404                // Put the HB outbound peer in the second slot, so that it
1405                // doesn't get removed.
1406                std::swap(lNodesAnnouncingHeaderAndIDs.front(), *std::next(lNodesAnnouncingHeaderAndIDs.begin()));
1407            }
1408        }
1409    }
1410    const bool nodeid_was_appended{m_connman.ForNode(nodeid, [this](CNode* pfrom) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
1411        AssertLockHeld(::cs_main);
1412        MakeAndPushMessage(*pfrom, NetMsgType::SENDCMPCT, /*high_bandwidth=*/true, /*version=*/CMPCTBLOCKS_VERSION);
1413        // save BIP152 bandwidth state: we select peer to be high-bandwidth
1414        pfrom->m_bip152_highbandwidth_to = true;
1415        lNodesAnnouncingHeaderAndIDs.push_back(pfrom->GetId());
1416        return true;
1417    })};
1418    if (nodeid_was_appended && lNodesAnnouncingHeaderAndIDs.size() > 3) {
1419        // As per BIP152, we only get 3 of our peers to announce
1420        // blocks using compact encodings.
1421        m_connman.ForNode(lNodesAnnouncingHeaderAndIDs.front(), [this](CNode* pnodeStop) {
1422            MakeAndPushMessage(*pnodeStop, NetMsgType::SENDCMPCT, /*high_bandwidth=*/false, /*version=*/CMPCTBLOCKS_VERSION);
1423            // save BIP152 bandwidth state: we select peer to be low-bandwidth
1424            pnodeStop->m_bip152_highbandwidth_to = false;
1425            return true;
1426        });
1427        lNodesAnnouncingHeaderAndIDs.pop_front();
1428    }
1429}
1430
1431bool PeerManagerImpl::TipMayBeStale()
1432{
1433    AssertLockHeld(cs_main);
1434    const Consensus::Params& consensusParams = m_chainparams.GetConsensus();
1435    if (m_last_tip_update.load() == 0s) {
1436        m_last_tip_update = GetTime<std::chrono::seconds>();
1437    }
1438    return m_last_tip_update.load() < GetTime<std::chrono::seconds>() - std::chrono::seconds{consensusParams.nPowTargetSpacing * 3} && mapBlocksInFlight.empty();
1439}
1440
1441int64_t PeerManagerImpl::ApproximateBestBlockDepth() const
1442{
1443    return (GetTime<std::chrono::seconds>() - m_best_block_time.load()).count() / m_chainparams.GetConsensus().nPowTargetSpacing;
1444}
1445
1446bool PeerManagerImpl::CanDirectFetch()
1447{
1448    return m_chainman.ActiveChain().Tip()->Time() > NodeClock::now() - m_chainparams.GetConsensus().PowTargetSpacing() * 20;
1449}
1450
1451static bool PeerHasHeader(CNodeState *state, const CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
1452{
1453    if (state->pindexBestKnownBlock && pindex == state->pindexBestKnownBlock->GetAncestor(pindex->nHeight))
1454        return true;
1455    if (state->pindexBestHeaderSent && pindex == state->pindexBestHeaderSent->GetAncestor(pindex->nHeight))
1456        return true;
1457    return false;
1458}
1459
1460void PeerManagerImpl::ProcessBlockAvailability(NodeId nodeid) {
1461    CNodeState *state = State(nodeid);
1462    assert(state != nullptr);
1463
1464    if (!state->hashLastUnknownBlock.IsNull()) {
1465        const CBlockIndex* pindex = m_chainman.m_blockman.LookupBlockIndex(state->hashLastUnknownBlock);
1466        if (pindex && pindex->nChainWork > 0) {
1467            if (state->pindexBestKnownBlock == nullptr || pindex->nChainWork >= state->pindexBestKnownBlock->nChainWork) {
1468                state->pindexBestKnownBlock = pindex;
1469            }
1470            state->hashLastUnknownBlock.SetNull();
1471        }
1472    }
1473}
1474
1475void PeerManagerImpl::UpdateBlockAvailability(NodeId nodeid, const uint256 &hash) {
1476    CNodeState *state = State(nodeid);
1477    assert(state != nullptr);
1478
1479    ProcessBlockAvailability(nodeid);
1480
1481    const CBlockIndex* pindex = m_chainman.m_blockman.LookupBlockIndex(hash);
1482    if (pindex && pindex->nChainWork > 0) {
1483        // An actually better block was announced.
1484        if (state->pindexBestKnownBlock == nullptr || pindex->nChainWork >= state->pindexBestKnownBlock->nChainWork) {
1485            state->pindexBestKnownBlock = pindex;
1486        }
1487    } else {
1488        // An unknown block was announced; just assume that the latest one is the best one.
1489        state->hashLastUnknownBlock = hash;
1490    }
1491}
1492
1493// Logic for calculating which blocks to download from a given peer, given our current tip.
1494void PeerManagerImpl::FindNextBlocksToDownload(const Peer& peer, unsigned int count, std::vector<const CBlockIndex*>& vBlocks, NodeId& nodeStaller)
1495{
1496    if (count == 0)
1497        return;
1498
1499    vBlocks.reserve(vBlocks.size() + count);
1500    CNodeState *state = State(peer.m_id);