EthereumPeer.h

Go to the documentation of this file.

/*
    This file is part of cpp-ethereum.
 
    cpp-ethereum is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    cpp-ethereum is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include "CommonNet.h"
 
namespace dev
{
namespace p2p
{
class CapabilityHostFace;
}
 
namespace eth
{
class EthereumPeer
{
public:
    EthereumPeer() = default;
    EthereumPeer(std::shared_ptr<p2p::CapabilityHostFace> _host, NodeID const& _peerID,
        u256 const& /*_capabilityVersion*/)
      : m_host(std::move(_host)), m_id(_peerID)
    {}
 
    void setStatus(unsigned _protocolVersion, u256 const& _networkId, u256 const& _totalDifficulty,
        h256 const& _latestHash, h256 const& _genesisHash);
 
    std::string validate(h256 const& _hostGenesisHash, unsigned _hostProtocolVersion,
        u256 const& _hostNetworkId) const;
 
    NodeID id() const { return m_id; }
 
    u256 totalDifficulty() const { return m_totalDifficulty; }
 
    time_t lastAsk() const { return m_lastAsk; }
    void setLastAsk(time_t _lastAsk) { m_lastAsk = _lastAsk; }
 
    Asking asking() const { return m_asking; }
    bool isConversing() const { return m_asking != Asking::Nothing; }
    void setAsking(Asking _asking) { m_asking = _asking; }
 
    h256 latestHash() const { return m_latestHash; }
    void setLatestHash(h256 const& _hash) { m_latestHash = _hash; }
 
    bool isWaitingForTransactions() const { return m_requireTransactions; }
    void setWaitingForTransactions(bool _value) { m_requireTransactions = _value; }
 
    bool isTransactionKnown(h256 const& _hash) const { return m_knownTransactions.count(_hash); }
    void markTransactionAsKnown(h256 const& _hash) { m_knownTransactions.insert(_hash); }
 
    bool isBlockKnown(h256 const& _hash) const { return m_knownBlocks.count(_hash); }
    void markBlockAsKnown(h256 const& _hash) { m_knownBlocks.insert(_hash); }
    void clearKnownBlocks() { m_knownBlocks.clear(); }
 
    unsigned unknownNewBlocks() const { return m_unknownNewBlocks; }
    void incrementUnknownNewBlocks() { ++m_unknownNewBlocks; }
 
    void requestStatus(u256 _hostNetworkId, u256 _chainTotalDifficulty, h256 _chainCurrentHash,
        h256 _chainGenesPeersh);
 
    void requestBlockHeaders(
        h256 const& _startHash, unsigned _count, unsigned _skip, bool _reverse);
    void requestBlockHeaders(unsigned _startNumber, unsigned _count, unsigned _skip, bool _reverse);
 
    void requestBlockBodies(h256s const& _blocks);
 
    void requestNodeData(h256s const& _hashes);
 
    void requestReceipts(h256s const& _blocks);
 
private:
    // Request of type _packetType with _hashes as input parameters
    void requestByHashes(h256s const& _hashes, Asking _asking, SubprotocolPacketType _packetType);
 
    std::shared_ptr<p2p::CapabilityHostFace> m_host;
 
    NodeID const m_id;
 
    Asking m_asking = Asking::Nothing;
    time_t m_lastAsk = 0;
    unsigned m_protocolVersion = 0;
    u256 m_networkId;
    h256 m_latestHash;
    u256 m_totalDifficulty;
    h256 m_genesisHash;  
    bool m_requireTransactions = false;
 
    h256Hash m_knownBlocks;
    h256Hash m_knownTransactions;     
    unsigned m_unknownNewBlocks = 0;  
    unsigned m_lastAskedHeaders = 0;  
 
    Logger m_logger{createLogger(VerbosityDebug, "peer")};
};
}  // namespace eth
}  // namespace dev