Method ReceivedAvalancheProof

src/net_processing.cpp:9329–9415

}

bool PeerManagerImpl::ReceivedAvalancheProof(CNode &node, Peer &peer,
                                             const avalanche::ProofRef &proof) {
    assert(proof != nullptr);

    const avalanche::ProofId &proofid = proof->getId();

    AddKnownProof(peer, proofid);

    if (m_chainman.IsInitialBlockDownload()) {
        // We cannot reliably verify proofs during IBD, so bail out early and
        // keep the inventory as pending so it can be requested when the node
        // has synced.
        return true;
    }

    const NodeId nodeid = node.GetId();

    const bool isStaker = WITH_LOCK(node.cs_avalanche_pubkey,
                                    return node.m_avalanche_pubkey.has_value());
    auto saveProofIfStaker = [this, isStaker](const CNode &node,
                                              const avalanche::ProofId &proofid,
                                              const NodeId nodeid) -> bool {
        if (isStaker) {
            return m_avalanche->withPeerManager(
                [&](avalanche::PeerManager &pm) {
                    return pm.saveRemoteProof(proofid, nodeid, true);
                });
        }

        return false;
    };

    {
        LOCK(cs_proofrequest);
        m_proofrequest.ReceivedResponse(nodeid, proofid);

        if (AlreadyHaveProof(proofid)) {
            m_proofrequest.ForgetInvId(proofid);
            saveProofIfStaker(node, proofid, nodeid);
            return true;
        }
    }

    // registerProof should not be called while cs_proofrequest because it
    // holds cs_main and that creates a potential deadlock during shutdown

    avalanche::ProofRegistrationState state;
    if (m_avalanche->withPeerManager([&](avalanche::PeerManager &pm) {
            return pm.registerProof(proof, state);
        })) {
        WITH_LOCK(cs_proofrequest, m_proofrequest.ForgetInvId(proofid));
        RelayProof(proofid);

        node.m_last_proof_time = GetTime<std::chrono::seconds>();

        LogPrint(BCLog::NET, "New avalanche proof: peer=%d, proofid %s\n",
                 nodeid, proofid.ToString());
    }