1501    assert(state != nullptr);
1502
1503    // Make sure pindexBestKnownBlock is up to date, we'll need it.
1504    ProcessBlockAvailability(peer.m_id);
1505
1506    if (state->pindexBestKnownBlock == nullptr || state->pindexBestKnownBlock->nChainWork < m_chainman.ActiveChain().Tip()->nChainWork || state->pindexBestKnownBlock->nChainWork < m_chainman.MinimumChainWork()) {
1507        // This peer has nothing interesting.
1508        return;
1509    }
1510
1511    // When syncing with AssumeUtxo and the snapshot has not yet been validated,
1512    // abort downloading blocks from peers that don't have the snapshot block in their best chain.
1513    // We can't reorg to this chain due to missing undo data until validation completes,
1514    // so downloading blocks from it would be futile.
1515    const CBlockIndex* snap_base{m_chainman.CurrentChainstate().SnapshotBase()};
1516    if (snap_base && m_chainman.CurrentChainstate().m_assumeutxo == Assumeutxo::UNVALIDATED &&
1517        state->pindexBestKnownBlock->GetAncestor(snap_base->nHeight) != snap_base) {
1518        LogDebug(BCLog::NET, "Not downloading blocks from peer=%d, which doesn't have the snapshot block in its best chain.\n", peer.m_id);
1519        return;
1520    }
1521
1522    // Determine the forking point between the peer's chain and our chain:
1523    // pindexLastCommonBlock is required to be an ancestor of pindexBestKnownBlock, and will be used as a starting point.
1524    // It is being set to the fork point between the peer's best known block and the current tip, unless it is already set to
1525    // an ancestor with more work than the fork point.
1526    auto fork_point = LastCommonAncestor(state->pindexBestKnownBlock, m_chainman.ActiveTip());
1527    if (state->pindexLastCommonBlock == nullptr ||
1528        fork_point->nChainWork > state->pindexLastCommonBlock->nChainWork ||
1529        state->pindexBestKnownBlock->GetAncestor(state->pindexLastCommonBlock->nHeight) != state->pindexLastCommonBlock) {
1530        state->pindexLastCommonBlock = fork_point;
1531    }
1532    if (state->pindexLastCommonBlock == state->pindexBestKnownBlock)
1533        return;
1534
1535    const CBlockIndex *pindexWalk = state->pindexLastCommonBlock;
1536    // Never fetch further than the best block we know the peer has, or more than BLOCK_DOWNLOAD_WINDOW + 1 beyond the last
1537    // linked block we have in common with this peer. The +1 is so we can detect stalling, namely if we would be able to
1538    // download that next block if the window were 1 larger.
1539    int nWindowEnd = state->pindexLastCommonBlock->nHeight + BLOCK_DOWNLOAD_WINDOW;
1540
1541    FindNextBlocks(vBlocks, peer, state, pindexWalk, count, nWindowEnd, &m_chainman.ActiveChain(), &nodeStaller);
1542}
1543
1544void PeerManagerImpl::TryDownloadingHistoricalBlocks(const Peer& peer, unsigned int count, std::vector<const CBlockIndex*>& vBlocks, const CBlockIndex *from_tip, const CBlockIndex* target_block)
1545{
1546    Assert(from_tip);
1547    Assert(target_block);
1548
1549    if (vBlocks.size() >= count) {
1550        return;
1551    }
1552
1553    vBlocks.reserve(count);
1554    CNodeState *state = Assert(State(peer.m_id));
1555
1556    if (state->pindexBestKnownBlock == nullptr || state->pindexBestKnownBlock->GetAncestor(target_block->nHeight) != target_block) {
1557        // This peer can't provide us the complete series of blocks leading up to the
1558        // assumeutxo snapshot base.
1559        //
1560        // Presumably this peer's chain has less work than our ActiveChain()'s tip, or else we
1561        // will eventually crash when we try to reorg to it. Let other logic
1562        // deal with whether we disconnect this peer.
1563        //
1564        // TODO at some point in the future, we might choose to request what blocks
1565        // this peer does have from the historical chain, despite it not having a
1566        // complete history beneath the snapshot base.
1567        return;
1568    }
1569
1570    FindNextBlocks(vBlocks, peer, state, from_tip, count, std::min<int>(from_tip->nHeight + BLOCK_DOWNLOAD_WINDOW, target_block->nHeight));
1571}
1572
1573void PeerManagerImpl::FindNextBlocks(std::vector<const CBlockIndex*>& vBlocks, const Peer& peer, CNodeState *state, const CBlockIndex *pindexWalk, unsigned int count, int nWindowEnd, const CChain* activeChain, NodeId* nodeStaller)
1574{
1575    std::vector<const CBlockIndex*> vToFetch;
1576    int nMaxHeight = std::min<int>(state->pindexBestKnownBlock->nHeight, nWindowEnd + 1);
1577    bool is_limited_peer = IsLimitedPeer(peer);
1578    NodeId waitingfor = -1;
1579    while (pindexWalk->nHeight < nMaxHeight) {
1580        // Read up to 128 (or more, if more blocks than that are needed) successors of pindexWalk (towards
1581        // pindexBestKnownBlock) into vToFetch. We fetch 128, because CBlockIndex::GetAncestor may be as expensive
1582        // as iterating over ~100 CBlockIndex* entries anyway.
1583        int nToFetch = std::min(nMaxHeight - pindexWalk->nHeight, std::max<int>(count - vBlocks.size(), 128));
1584        vToFetch.resize(nToFetch);
1585        pindexWalk = state->pindexBestKnownBlock->GetAncestor(pindexWalk->nHeight + nToFetch);
1586        vToFetch[nToFetch - 1] = pindexWalk;
1587        for (unsigned int i = nToFetch - 1; i > 0; i--) {
1588            vToFetch[i - 1] = vToFetch[i]->pprev;
1589        }
1590
1591        // Iterate over those blocks in vToFetch (in forward direction), adding the ones that
1592        // are not yet downloaded and not in flight to vBlocks. In the meantime, update
1593        // pindexLastCommonBlock as long as all ancestors are already downloaded, or if it's
1594        // already part of our chain (and therefore don't need it even if pruned).
1595        for (const CBlockIndex* pindex : vToFetch) {
1596            if (!pindex->IsValid(BLOCK_VALID_TREE)) {
1597                // We consider the chain that this peer is on invalid.
1598                return;
1599            }
1600
1601            if (!CanServeWitnesses(peer) && DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_SEGWIT)) {
1602                // We wouldn't download this block or its descendants from this peer.
1603                return;
1604            }
1605
1606            if (pindex->nStatus & BLOCK_HAVE_DATA || (activeChain && activeChain->Contains(*pindex))) {
1607                if (activeChain && pindex->HaveNumChainTxs()) {
1608                    state->pindexLastCommonBlock = pindex;
1609                }
1610                continue;
1611            }
1612
1613            // Is block in-flight?
1614            if (IsBlockRequested(pindex->GetBlockHash())) {
1615                if (waitingfor == -1) {
1616                    // This is the first already-in-flight block.
1617                    waitingfor = mapBlocksInFlight.lower_bound(pindex->GetBlockHash())->second.first;
1618                }
1619                continue;
1620            }
1621
1622            // The block is not already downloaded, and not yet in flight.
1623            if (pindex->nHeight > nWindowEnd) {
1624                // We reached the end of the window.
1625                if (vBlocks.size() == 0 && waitingfor != peer.m_id) {
1626                    // We aren't able to fetch anything, but we would be if the download window was one larger.
1627                    if (nodeStaller) *nodeStaller = waitingfor;
1628                }
1629                return;
1630            }
1631
1632            // Don't request blocks that go further than what limited peers can provide
1633            if (is_limited_peer && (state->pindexBestKnownBlock->nHeight - pindex->nHeight >= static_cast<int>(NODE_NETWORK_LIMITED_MIN_BLOCKS) - 2 /* two blocks buffer for possible races */)) {
1634                continue;
1635            }
1636
1637            vBlocks.push_back(pindex);
1638            if (vBlocks.size() == count) {
1639                return;
1640            }
1641        }
1642    }
1643}
1644
1645} // namespace
1646
1647void PeerManagerImpl::PushNodeVersion(CNode& pnode, const Peer& peer)
1648{
1649    uint64_t my_services;
1650    int64_t my_time;
1651    uint64_t your_services;
1652    CService your_addr;
1653    std::string my_user_agent;
1654    int my_height;
1655    bool my_tx_relay;
1656    if (pnode.IsPrivateBroadcastConn()) {
1657        my_services = NODE_NONE;
1658        my_time = 0;
1659        your_services = NODE_NONE;
1660        your_addr = CService{};
1661        my_user_agent = "/pynode:0.0.1/"; // Use a constant other than the default (or user-configured). See https://github.com/bitcoin/bitcoin/pull/27509#discussion_r1214671917
1662        my_height = 0;
1663        my_tx_relay = false;
1664    } else {
1665        const CAddress& addr{pnode.addr};
1666        my_services = peer.m_our_services;
1667        my_time = TicksSinceEpoch<std::chrono::seconds>(NodeClock::now());
1668        your_services = addr.nServices;
1669        your_addr = addr.IsRoutable() && !IsProxy(addr) && addr.IsAddrV1Compatible() ? CService{addr} : CService{};
1670        my_user_agent = strSubVersion;
1671        my_height = m_best_height;
1672        my_tx_relay = !RejectIncomingTxs(pnode);
1673    }
1674
1675    MakeAndPushMessage(
1676        pnode,
1677        NetMsgType::VERSION,
1678        pnode.AdvertisedVersion(),
1679        my_services,
1680        my_time,
1681        // your_services + CNetAddr::V1(your_addr) is the pre-version-31402 serialization of your_addr (without nTime)
1682        your_services, CNetAddr::V1(your_addr),
1683        // same, for a dummy address
1684        my_services, CNetAddr::V1(CService{}),
1685        pnode.GetLocalNonce(),
1686        my_user_agent,
1687        my_height,
1688        my_tx_relay);
1689
1690    LogDebug(
1691        BCLog::NET, "send version message: version=%d, blocks=%d%s, txrelay=%d, peer=%d\n",
1692        pnode.AdvertisedVersion(), my_height,
1693        fLogIPs ? strprintf(", them=%s", your_addr.ToStringAddrPort()) : "",
1694        my_tx_relay, pnode.GetId());
1695}
1696
1697void PeerManagerImpl::UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds)
1698{
1699    LOCK(cs_main);
1700    CNodeState *state = State(node);
1701    if (state) state->m_last_block_announcement = time_in_seconds;
1702}
1703
1704void PeerManagerImpl::InitializeNode(const CNode& node, ServiceFlags our_services)
1705{
1706    NodeId nodeid = node.GetId();
1707    {
1708        LOCK(cs_main); // For m_node_states
1709        m_node_states.try_emplace(m_node_states.end(), nodeid);
1710    }
1711    WITH_LOCK(m_tx_download_mutex, m_txdownloadman.CheckIsEmpty(nodeid));
1712
1713    if (NetPermissions::HasFlag(node.m_permission_flags, NetPermissionFlags::BloomFilter)) {
1714        our_services = static_cast<ServiceFlags>(our_services | NODE_BLOOM);
1715    }
1716
1717    PeerRef peer = std::make_shared<Peer>(nodeid, our_services, node.IsInboundConn());
1718    {
1719        LOCK(m_peer_mutex);
1720        m_peer_map.emplace_hint(m_peer_map.end(), nodeid, peer);
1721    }
1722}
1723
1724void PeerManagerImpl::ReattemptInitialBroadcast(CScheduler& scheduler)
1725{
1726    std::set<Txid> unbroadcast_txids = m_mempool.GetUnbroadcastTxs();
1727
1728    for (const auto& txid : unbroadcast_txids) {
1729        CTransactionRef tx = m_mempool.get(txid);
1730
1731        if (tx != nullptr) {
1732            InitiateTxBroadcastToAll(tx->GetWitnessHash());
1733        } else {
1734            m_mempool.RemoveUnbroadcastTx(txid, true);
1735        }
1736    }
1737
1738    // Schedule next run for 10-15 minutes in the future.
1739    // We add randomness on every cycle to avoid the possibility of P2P fingerprinting.
1740    const auto delta = 10min + FastRandomContext().randrange<std::chrono::milliseconds>(5min);
1741    scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); }, delta);
1742}
1743
1744void PeerManagerImpl::ReattemptPrivateBroadcast(CScheduler& scheduler)
1745{
1746    // Resolve stale transactions that are no longer relevant (e.g. already in
1747    // the mempool or mined) and count the remaining ones.
1748    size_t num_for_rebroadcast{0};
1749    const auto stale_txs = m_tx_for_private_broadcast.GetStale();
1750    if (!stale_txs.empty()) {