3501                orphan_wtxid.ToString(),
3502                peer.m_id,
3503                state.ToString());
3504
3505            if (Assume(state.IsInvalid() &&
3506                       state.GetResult() != TxValidationResult::TX_UNKNOWN &&
3507                       state.GetResult() != TxValidationResult::TX_NO_MEMPOOL &&
3508                       state.GetResult() != TxValidationResult::TX_RESULT_UNSET)) {
3509                ProcessInvalidTx(peer.m_id, porphanTx, state, /*first_time_failure=*/false);
3510            }
3511            return true;
3512        }
3513    }
3514
3515    return false;
3516}
3517
3518bool PeerManagerImpl::PrepareBlockFilterRequest(CNode& node, Peer& peer,
3519                                                BlockFilterType filter_type, uint32_t start_height,
3520                                                const uint256& stop_hash, uint32_t max_height_diff,
3521                                                const CBlockIndex*& stop_index,
3522                                                BlockFilterIndex*& filter_index)
3523{
3524    const bool supported_filter_type =
3525        (filter_type == BlockFilterType::BASIC &&
3526         (peer.m_our_services & NODE_COMPACT_FILTERS));
3527    if (!supported_filter_type) {
3528        LogDebug(BCLog::NET, "peer requested unsupported block filter type: %d, %s",
3529                 static_cast<uint8_t>(filter_type), node.DisconnectMsg());
3530        node.fDisconnect = true;
3531        return false;
3532    }
3533
3534    {
3535        LOCK(cs_main);
3536        stop_index = m_chainman.m_blockman.LookupBlockIndex(stop_hash);
3537
3538        // Check that the stop block exists and the peer would be allowed to fetch it.
3539        if (!stop_index || !BlockRequestAllowed(*stop_index)) {
3540            LogDebug(BCLog::NET, "peer requested invalid block hash: %s, %s",
3541                     stop_hash.ToString(), node.DisconnectMsg());
3542            node.fDisconnect = true;
3543            return false;
3544        }
3545    }
3546
3547    uint32_t stop_height = stop_index->nHeight;
3548    if (start_height > stop_height) {
3549        LogDebug(BCLog::NET, "peer sent invalid getcfilters/getcfheaders with "
3550                 "start height %d and stop height %d, %s",
3551                 start_height, stop_height, node.DisconnectMsg());
3552        node.fDisconnect = true;
3553        return false;
3554    }
3555    if (stop_height - start_height >= max_height_diff) {
3556        LogDebug(BCLog::NET, "peer requested too many cfilters/cfheaders: %d / %d, %s",
3557                 stop_height - start_height + 1, max_height_diff, node.DisconnectMsg());
3558        node.fDisconnect = true;
3559        return false;
3560    }
3561
3562    filter_index = GetBlockFilterIndex(filter_type);
3563    if (!filter_index) {
3564        LogDebug(BCLog::NET, "Filter index for supported type %s not found\n", BlockFilterTypeName(filter_type));
3565        return false;
3566    }
3567
3568    return true;
3569}
3570
3571void PeerManagerImpl::ProcessGetCFilters(CNode& node, Peer& peer, DataStream& vRecv)
3572{
3573    uint8_t filter_type_ser;
3574    uint32_t start_height;
3575    uint256 stop_hash;
3576
3577    vRecv >> filter_type_ser >> start_height >> stop_hash;
3578
3579    const BlockFilterType filter_type = static_cast<BlockFilterType>(filter_type_ser);
3580
3581    const CBlockIndex* stop_index;
3582    BlockFilterIndex* filter_index;
3583    if (!PrepareBlockFilterRequest(node, peer, filter_type, start_height, stop_hash,
3584                                   MAX_GETCFILTERS_SIZE, stop_index, filter_index)) {
3585        return;
3586    }
3587
3588    std::vector<BlockFilter> filters;
3589    if (!filter_index->LookupFilterRange(start_height, stop_index, filters)) {
3590        LogDebug(BCLog::NET, "Failed to find block filter in index: filter_type=%s, start_height=%d, stop_hash=%s\n",
3591                     BlockFilterTypeName(filter_type), start_height, stop_hash.ToString());
3592        return;
3593    }
3594
3595    for (const auto& filter : filters) {
3596        MakeAndPushMessage(node, NetMsgType::CFILTER, filter);
3597    }
3598}
3599
3600void PeerManagerImpl::ProcessGetCFHeaders(CNode& node, Peer& peer, DataStream& vRecv)
3601{
3602    uint8_t filter_type_ser;
3603    uint32_t start_height;
3604    uint256 stop_hash;
3605
3606    vRecv >> filter_type_ser >> start_height >> stop_hash;
3607
3608    const BlockFilterType filter_type = static_cast<BlockFilterType>(filter_type_ser);
3609
3610    const CBlockIndex* stop_index;
3611    BlockFilterIndex* filter_index;
3612    if (!PrepareBlockFilterRequest(node, peer, filter_type, start_height, stop_hash,
3613                                   MAX_GETCFHEADERS_SIZE, stop_index, filter_index)) {
3614        return;
3615    }
3616
3617    uint256 prev_header;
3618    if (start_height > 0) {
3619        const CBlockIndex* const prev_block =
3620            stop_index->GetAncestor(static_cast<int>(start_height - 1));
3621        if (!filter_index->LookupFilterHeader(prev_block, prev_header)) {
3622            LogDebug(BCLog::NET, "Failed to find block filter header in index: filter_type=%s, block_hash=%s\n",
3623                         BlockFilterTypeName(filter_type), prev_block->GetBlockHash().ToString());
3624            return;
3625        }
3626    }
3627
3628    std::vector<uint256> filter_hashes;
3629    if (!filter_index->LookupFilterHashRange(start_height, stop_index, filter_hashes)) {
3630        LogDebug(BCLog::NET, "Failed to find block filter hashes in index: filter_type=%s, start_height=%d, stop_hash=%s\n",
3631                     BlockFilterTypeName(filter_type), start_height, stop_hash.ToString());
3632        return;
3633    }
3634
3635    MakeAndPushMessage(node, NetMsgType::CFHEADERS,
3636              filter_type_ser,
3637              stop_index->GetBlockHash(),
3638              prev_header,
3639              filter_hashes);
3640}
3641
3642void PeerManagerImpl::ProcessGetCFCheckPt(CNode& node, Peer& peer, DataStream& vRecv)
3643{
3644    uint8_t filter_type_ser;
3645    uint256 stop_hash;
3646
3647    vRecv >> filter_type_ser >> stop_hash;
3648
3649    const BlockFilterType filter_type = static_cast<BlockFilterType>(filter_type_ser);
3650
3651    const CBlockIndex* stop_index;
3652    BlockFilterIndex* filter_index;
3653    if (!PrepareBlockFilterRequest(node, peer, filter_type, /*start_height=*/0, stop_hash,
3654                                   /*max_height_diff=*/std::numeric_limits<uint32_t>::max(),
3655                                   stop_index, filter_index)) {
3656        return;
3657    }
3658
3659    std::vector<uint256> headers(stop_index->nHeight / CFCHECKPT_INTERVAL);
3660
3661    // Populate headers.
3662    const CBlockIndex* block_index = stop_index;
3663    for (int i = headers.size() - 1; i >= 0; i--) {
3664        int height = (i + 1) * CFCHECKPT_INTERVAL;
3665        block_index = block_index->GetAncestor(height);
3666
3667        if (!filter_index->LookupFilterHeader(block_index, headers[i])) {
3668            LogDebug(BCLog::NET, "Failed to find block filter header in index: filter_type=%s, block_hash=%s\n",
3669                         BlockFilterTypeName(filter_type), block_index->GetBlockHash().ToString());
3670            return;
3671        }
3672    }
3673
3674    MakeAndPushMessage(node, NetMsgType::CFCHECKPT,
3675              filter_type_ser,
3676              stop_index->GetBlockHash(),
3677              headers);
3678}
3679
3680void PeerManagerImpl::ProcessBlock(CNode& node, const std::shared_ptr<const CBlock>& block, bool force_processing, bool min_pow_checked)
3681{
3682    bool new_block{false};
3683    m_chainman.ProcessNewBlock(block, force_processing, min_pow_checked, &new_block);
3684    if (new_block) {
3685        node.m_last_block_time = GetTime<std::chrono::seconds>();
3686        // In case this block came from a different peer than we requested
3687        // from, we can erase the block request now anyway (as we just stored
3688        // this block to disk).
3689        LOCK(cs_main);
3690        RemoveBlockRequest(block->GetHash(), std::nullopt);
3691    } else {
3692        LOCK(cs_main);
3693        mapBlockSource.erase(block->GetHash());
3694    }
3695}
3696
3697void PeerManagerImpl::ProcessCompactBlockTxns(CNode& pfrom, Peer& peer, const BlockTransactions& block_transactions)
3698{
3699    std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
3700    bool fBlockRead{false};
3701    {
3702        LOCK(cs_main);
3703
3704        auto range_flight = mapBlocksInFlight.equal_range(block_transactions.blockhash);
3705        size_t already_in_flight = std::distance(range_flight.first, range_flight.second);
3706        bool requested_block_from_this_peer{false};
3707
3708        // Multimap ensures ordering of outstanding requests. It's either empty or first in line.
3709        bool first_in_flight = already_in_flight == 0 || (range_flight.first->second.first == pfrom.GetId());
3710
3711        while (range_flight.first != range_flight.second) {
3712            auto [node_id, block_it] = range_flight.first->second;
3713            if (node_id == pfrom.GetId() && block_it->partialBlock) {
3714                requested_block_from_this_peer = true;
3715                break;
3716            }
3717            range_flight.first++;
3718        }
3719
3720        if (!requested_block_from_this_peer) {
3721            LogDebug(BCLog::NET, "Peer %d sent us block transactions for block we weren't expecting\n", pfrom.GetId());
3722            return;
3723        }
3724
3725        PartiallyDownloadedBlock& partialBlock = *range_flight.first->second.second->partialBlock;
3726
3727        if (partialBlock.header.IsNull()) {
3728            // It is possible for the header to be empty if a previous call to FillBlock wiped the header, but left
3729            // the PartiallyDownloadedBlock pointer around (i.e. did not call RemoveBlockRequest). In this case, we
3730            // should not call LookupBlockIndex below.
3731            RemoveBlockRequest(block_transactions.blockhash, pfrom.GetId());
3732            Misbehaving(peer, "previous compact block reconstruction attempt failed");
3733            LogDebug(BCLog::NET, "Peer %d sent compact block transactions multiple times", pfrom.GetId());
3734            return;
3735        }
3736
3737        // We should not have gotten this far in compact block processing unless it's attached to a known header
3738        const CBlockIndex* prev_block{Assume(m_chainman.m_blockman.LookupBlockIndex(partialBlock.header.hashPrevBlock))};
3739        ReadStatus status = partialBlock.FillBlock(*pblock, block_transactions.txn,
3740                                                   /*segwit_active=*/DeploymentActiveAfter(prev_block, m_chainman, Consensus::DEPLOYMENT_SEGWIT));
3741        if (status == READ_STATUS_INVALID) {
3742            RemoveBlockRequest(block_transactions.blockhash, pfrom.GetId()); // Reset in-flight state in case Misbehaving does not result in a disconnect
3743            Misbehaving(peer, "invalid compact block/non-matching block transactions");
3744            return;
3745        } else if (status == READ_STATUS_FAILED) {
3746            if (first_in_flight) {
3747                // Might have collided, fall back to getdata now :(
3748                // We keep the failed partialBlock to disallow processing another compact block announcement from the same
3749                // peer for the same block. We let the full block download below continue under the same m_downloading_since
3750                // timer.