Merge pull request #2024 from arkpar/bc

Blockchain sync refactoring

libethcore/Common.cpp

@@ -35,7 +35,7 @@ namespace dev
 namespace eth
 {
 
-const unsigned c_protocolVersion = 60;
+const unsigned c_protocolVersion = 61;
 #if ETH_FATDB
 const unsigned c_minorProtocolVersion = 3;
 const unsigned c_databaseBaseVersion = 9;

libethereum/BlockChain.cpp

@@ -317,7 +317,7 @@ tuple<h256s, h256s, bool> BlockChain::sync(BlockQueue& _bq, OverlayDB const& _st
 	{
 		try
 		{
-			// Nonce & uncle nonces already verified thread at this point.
+			// Nonce & uncle nonces already verified in verification thread at this point.
 			ImportRoute r;
 			DEV_TIMED_ABOVE(Block import, 500)
 				r = import(block.first, block.second, _stateDB, ImportRequirements::Default & ~ImportRequirements::ValidNonce & ~ImportRequirements::CheckUncles);

libethereum/CanonBlockChain.h

@@ -34,7 +34,6 @@
 #include <libdevcore/Guards.h>
 #include "BlockDetails.h"
 #include "Account.h"
-#include "BlockQueue.h"
 #include "BlockChain.h"
 namespace ldb = leveldb;
 

libethereum/Client.cpp

@@ -164,28 +164,8 @@ const char* ClientDetail::name() { return EthTeal "⧫" EthCoal " ●"; }
 #endif
 
 Client::Client(p2p::Host* _extNet, std::string const& _dbPath, WithExisting _forceAction, u256 _networkId):
-	Worker("eth", 0),
+	Client(_extNet, make_shared<TrivialGasPricer>(), _dbPath, _forceAction, _networkId)
-	m_vc(_dbPath),
-	m_bc(_dbPath, max(m_vc.action(), _forceAction), [](unsigned d, unsigned t){ cerr << "REVISING BLOCKCHAIN: Processed " << d << " of " << t << "...\r"; }),
-	m_gp(new TrivialGasPricer),
-	m_stateDB(State::openDB(_dbPath, max(m_vc.action(), _forceAction))),
-	m_preMine(m_stateDB, BaseState::CanonGenesis),
-	m_postMine(m_stateDB)
 {
-	m_lastGetWork = std::chrono::system_clock::now() - chrono::seconds(30);
-	m_tqReady = m_tq.onReady([=](){ this->onTransactionQueueReady(); });	// TODO: should read m_tq->onReady(thisThread, syncTransactionQueue);
-	m_bqReady = m_bq.onReady([=](){ this->onBlockQueueReady(); });			// TODO: should read m_bq->onReady(thisThread, syncBlockQueue);
-	m_farm.onSolutionFound([=](ProofOfWork::Solution const& s){ return this->submitWork(s); });
-
-	m_gp->update(m_bc);
-
-	m_host = _extNet->registerCapability(new EthereumHost(m_bc, m_tq, m_bq, _networkId));
-
-	if (_dbPath.size())
-		Defaults::setDBPath(_dbPath);
-	m_vc.setOk();
-	doWork();
-
 	startWorking();
 }
 
@@ -195,7 +175,7 @@ Client::Client(p2p::Host* _extNet, std::shared_ptr<GasPricer> _gp, std::string c
 	m_bc(_dbPath, max(m_vc.action(), _forceAction), [](unsigned d, unsigned t){ cerr << "REVISING BLOCKCHAIN: Processed " << d << " of " << t << "...\r"; }),
 	m_gp(_gp),
 	m_stateDB(State::openDB(_dbPath, max(m_vc.action(), _forceAction))),
-	m_preMine(m_stateDB),
+	m_preMine(m_stateDB, BaseState::CanonGenesis),
 	m_postMine(m_stateDB)
 {
 	m_lastGetWork = std::chrono::system_clock::now() - chrono::seconds(30);
@@ -205,7 +185,9 @@ Client::Client(p2p::Host* _extNet, std::shared_ptr<GasPricer> _gp, std::string c
 
 	m_gp->update(m_bc);
 
-	m_host = _extNet->registerCapability(new EthereumHost(m_bc, m_tq, m_bq, _networkId));
+	auto host = _extNet->registerCapability(new EthereumHost(m_bc, m_tq, m_bq, _networkId));
+	m_host = host;
+	_extNet->addCapability(host, EthereumHost::staticName(), EthereumHost::c_oldProtocolVersion); //TODO: remove this one v61+ protocol is common
 
 	if (_dbPath.size())
 		Defaults::setDBPath(_dbPath);

libethereum/CommonNet.h

@@ -38,12 +38,12 @@ namespace eth
 
 #if ETH_DEBUG
 static const unsigned c_maxHashes = 2048;		///< Maximum number of hashes BlockHashes will ever send.
-static const unsigned c_maxHashesAsk = 2048;		///< Maximum number of hashes GetBlockHashes will ever ask for.
+static const unsigned c_maxHashesAsk = 2048;	///< Maximum number of hashes GetBlockHashes will ever ask for.
 static const unsigned c_maxBlocks = 128;		///< Maximum number of blocks Blocks will ever send.
 static const unsigned c_maxBlocksAsk = 128;		///< Maximum number of blocks we ask to receive in Blocks (when using GetChain).
 #else
 static const unsigned c_maxHashes = 2048;		///< Maximum number of hashes BlockHashes will ever send.
-static const unsigned c_maxHashesAsk = 2048;		///< Maximum number of hashes GetBlockHashes will ever ask for.
+static const unsigned c_maxHashesAsk = 2048;	///< Maximum number of hashes GetBlockHashes will ever ask for.
 static const unsigned c_maxBlocks = 128;		///< Maximum number of blocks Blocks will ever send.
 static const unsigned c_maxBlocksAsk = 128;		///< Maximum number of blocks we ask to receive in Blocks (when using GetChain).
 #endif
@@ -63,6 +63,7 @@ enum
 	GetBlocksPacket,
 	BlocksPacket,
 	NewBlockPacket,
+	GetBlockHashesByNumberPacket,
 	PacketCount
 };
 

libethereum/DownloadMan.cpp

@@ -75,3 +75,53 @@ bool DownloadSub::noteBlock(h256 _hash)
 	m_remaining.erase(_hash);
 	return ret;
 }
+
+HashDownloadSub::HashDownloadSub(HashDownloadMan& _man): m_man(&_man)
+{
+	WriteGuard l(m_man->x_subs);
+	m_asked = RangeMask<unsigned>(m_man->m_chainStart, m_man->m_chainStart + m_man->m_chainCount);
+	m_attempted = RangeMask<unsigned>(m_man->m_chainStart, m_man->m_chainStart + m_man->m_chainCount);
+	m_man->m_subs.insert(this);
+}
+
+HashDownloadSub::~HashDownloadSub()
+{
+	if (m_man)
+	{
+		WriteGuard l(m_man->x_subs);
+		m_man->m_subs.erase(this);
+	}
+}
+
+void HashDownloadSub::resetFetch()
+{
+	Guard l(m_fetch);
+	m_remaining = 0;
+	m_asked = RangeMask<unsigned>(m_man->m_chainStart, m_man->m_chainStart + m_man->m_chainCount);
+	m_attempted = RangeMask<unsigned>(m_man->m_chainStart, m_man->m_chainStart + m_man->m_chainCount);
+}
+
+unsigned HashDownloadSub::nextFetch(unsigned _n)
+{
+	Guard l(m_fetch);
+
+	m_asked = RangeMask<unsigned>(m_man->m_chainStart, m_man->m_chainStart + m_man->m_chainCount);
+
+	if (!m_man || m_man->chainEmpty())
+		return 0;
+
+	m_asked = (~(m_man->taken() + m_attempted)).lowest(_n);
+	if (m_asked.empty())
+		m_asked = (~(m_man->taken(true) + m_attempted)).lowest(_n);
+	m_attempted += m_asked;
+	return *m_asked.begin();
+}
+
+void HashDownloadSub::noteHash(unsigned _index, unsigned _size)
+{
+	Guard l(m_fetch);
+	if (m_man)
+		for(unsigned i = _index; i < _index + _size; ++i)
+			if (i >= m_man->m_got.all().first && i < m_man->m_got.all().second)
+				m_man->m_got += i;
+}

libethereum/DownloadMan.h

@@ -88,6 +88,13 @@ public:
 			i->m_man = nullptr;
 	}
 
+	void appendToChain(h256s const& _hashes)
+	{
+		WriteGuard l(m_lock);
+		m_chain.insert(m_chain.end(), _hashes.cbegin(), _hashes.cend());
+		m_blocksGot = RangeMask<unsigned>(0, m_chain.size());
+	}
+
 	void resetToChain(h256s const& _chain)
 	{
 		{
@@ -158,6 +165,112 @@ private:
 	std::unordered_set<DownloadSub*> m_subs;
 };
 
+
+class HashDownloadMan;
+
+class HashDownloadSub
+{
+	friend class HashDownloadMan;
+
+public:
+	HashDownloadSub(HashDownloadMan& _man);
+	~HashDownloadSub();
+
+	/// Finished last fetch - grab the next hash index to download
+	unsigned nextFetch(unsigned _n);
+
+	/// Note that we've received a particular hash range.
+	void noteHash(unsigned _index, unsigned count);
+
+	/// Nothing doing here.
+	void doneFetch() { resetFetch(); }
+
+	bool askedContains(unsigned _i) const { Guard l(m_fetch); return m_asked.contains(_i); }
+	RangeMask<unsigned> const& asked() const { return m_asked; }
+	RangeMask<unsigned> const& attemped() const { return m_attempted; }
+
+private:
+	void resetFetch();		// Called by DownloadMan when we need to reset the download.
+
+	HashDownloadMan* m_man = nullptr;
+	mutable Mutex m_fetch;
+	unsigned m_remaining;
+	RangeMask<unsigned> m_asked;
+	RangeMask<unsigned> m_attempted;
+};
+
+class HashDownloadMan
+{
+	friend class HashDownloadSub;
+
+public:
+	~HashDownloadMan()
+	{
+		for (auto i: m_subs)
+			i->m_man = nullptr;
+	}
+
+	void resetToRange(unsigned _start, unsigned _count)
+	{
+		{
+			ReadGuard l(x_subs);
+			for (auto i: m_subs)
+				i->resetFetch();
+		}
+		WriteGuard l(m_lock);
+		m_chainStart = _start;
+		m_chainCount = _count;
+		m_got += RangeMask<unsigned>(_start, _start + _count);
+		{
+			ReadGuard l(x_subs);
+			for (auto i: m_subs)
+				i->resetFetch();
+		}
+	}
+
+	void reset(unsigned _start)
+	{
+		WriteGuard l(m_lock);
+		m_chainStart = _start;
+		m_chainCount = 0;
+		m_got = RangeMask<unsigned>(_start, _start);
+	}
+
+	RangeMask<unsigned> taken(bool _desperate = false) const
+	{
+		ReadGuard l(m_lock);
+		auto ret = m_got;
+		if (!_desperate)
+		{
+			ReadGuard l(x_subs);
+			for (auto i: m_subs)
+				ret += i->m_asked;
+		}
+		return ret;
+	}
+
+	bool isComplete() const
+	{
+		ReadGuard l(m_lock);
+		return m_got.full();
+	}
+
+	size_t chainSize() const { ReadGuard l(m_lock); return m_chainCount; }
+	size_t chainEmpty() const { ReadGuard l(m_lock); return m_chainCount == 0; }
+	void foreachSub(std::function<void(HashDownloadSub const&)> const& _f) const { ReadGuard l(x_subs); for(auto i: m_subs) _f(*i); }
+	unsigned subCount() const { ReadGuard l(x_subs); return m_subs.size(); }
+	RangeMask<unsigned> hashesGot() const { ReadGuard l(m_lock); return m_got; }
+
+private:
+	mutable SharedMutex m_lock;
+	unsigned m_chainStart = 0;
+	unsigned m_chainCount = 0;
+	RangeMask<unsigned> m_got;
+
+	mutable SharedMutex x_subs;
+	std::unordered_set<HashDownloadSub*> m_subs;
+};
+
 }
 
 }

libethereum/EthereumHost.cpp

@@ -27,6 +27,7 @@
 #include <libp2p/Host.h>
 #include <libp2p/Session.h>
 #include <libethcore/Exceptions.h>
+#include <libethcore/Params.h>
 #include "BlockChain.h"
 #include "TransactionQueue.h"
 #include "BlockQueue.h"
@@ -37,6 +38,8 @@ using namespace dev;
 using namespace dev::eth;
 using namespace p2p;
 
+unsigned const EthereumHost::c_oldProtocolVersion = 60; //TODO: remove this once v61+ is common
+
 EthereumHost::EthereumHost(BlockChain const& _ch, TransactionQueue& _tq, BlockQueue& _bq, u256 _networkId):
 	HostCapability<EthereumPeer>(),
 	Worker		("ethsync"),
@@ -46,12 +49,12 @@ EthereumHost::EthereumHost(BlockChain const& _ch, TransactionQueue& _tq, BlockQu
 	m_networkId	(_networkId)
 {
 	m_latestBlockSent = _ch.currentHash();
+	m_hashMan.reset(m_chain.number() + 1);
 }
 
 EthereumHost::~EthereumHost()
 {
-	for (auto i: peerSessions())
+	forEachPeer([](EthereumPeer* _p) { _p->abortSync(); });
-		i.first->cap<EthereumPeer>().get()->abortSync();
 }
 
 bool EthereumHost::ensureInitialised()
@@ -69,88 +72,18 @@ bool EthereumHost::ensureInitialised()
 	return false;
 }
 
-void EthereumHost::noteNeedsSyncing(EthereumPeer* _who)
-{
-	// if already downloading hash-chain, ignore.
-	if (isSyncing())
-	{
-		clog(NetAllDetail) << "Sync in progress: Just set to help out.";
-		if (m_syncer->m_asking == Asking::Blocks)
-			_who->transition(Asking::Blocks);
-	}
-	else
-		// otherwise check to see if we should be downloading...
-		_who->attemptSync();
-}
-
-void EthereumHost::changeSyncer(EthereumPeer* _syncer, bool _needHelp)
-{
-	if (_syncer)
-		clog(NetAllDetail) << "Changing syncer to" << _syncer->session()->socketId();
-	else
-		clog(NetAllDetail) << "Clearing syncer.";
-
-	m_syncer = _syncer;
-	if (isSyncing())
-	{
-		if (_needHelp && _syncer->m_asking == Asking::Blocks)
-			for (auto j: peerSessions())
-			{
-				clog(NetNote) << "Getting help with downloading blocks";
-				auto e = j.first->cap<EthereumPeer>().get();
-				if (e != _syncer && e->m_asking == Asking::Nothing)
-					e->transition(Asking::Blocks);
-			}
-	}
-	else
-	{
-		// start grabbing next hash chain if there is one.
-		for (auto j: peerSessions())
-		{
-			j.first->cap<EthereumPeer>()->attemptSync();
-			if (isSyncing())
-				return;
-		}
-		clog(NetNote) << "No more peers to sync with.";
-	}
-}
-
-void EthereumHost::noteDoneBlocks(EthereumPeer* _who, bool _clemency)
-{
-	if (m_man.isComplete())
-	{
-		// Done our chain-get.
-		clog(NetNote) << "Chain download complete.";
-		// 1/100th for each useful block hash.
-		_who->addRating(m_man.chainSize() / 100);
-		m_man.reset();
-	}
-	else if (_who->isSyncing())
-	{
-		if (_clemency)
-			clog(NetNote) << "Chain download failed. Aborted while incomplete.";
-		else
-		{
-			// Done our chain-get.
-			clog(NetWarn) << "Chain download failed. Peer with blocks didn't have them all. This peer is bad and should be punished.";
-			clog(NetWarn) << m_man.remaining();
-			clog(NetWarn) << "WOULD BAN.";
-//			m_banned.insert(_who->session()->id());			// We know who you are!
-//			_who->disable("Peer sent hashes but was unable to provide the blocks.");
-		}
-		m_man.reset();
-	}
-}
-
 void EthereumHost::reset()
 {
-	if (m_syncer)
+	forEachPeer([](EthereumPeer* _p) { _p->abortSync(); });
-		m_syncer->abortSync();
-
 	m_man.resetToChain(h256s());
-
+	m_hashMan.reset(m_chain.number() + 1);
+	m_needSyncBlocks = true;
+	m_needSyncHashes = true;
+	m_syncingLatestHash = h256();
+	m_syncingTotalDifficulty = 0;
 	m_latestBlockSent = h256();
 	m_transactionsSent.clear();
+	m_hashes.clear();
 }
 
 void EthereumHost::doWork()
@@ -172,9 +105,7 @@ void EthereumHost::doWork()
 		}
 	}
 
-	for (auto p: peerSessions())
+	forEachPeer([](EthereumPeer* _p) { _p->tick(); });
-		if (shared_ptr<EthereumPeer> const& ep = p.first->cap<EthereumPeer>())
-			ep->tick();
 
 //	return netChange;
 	// TODO: Figure out what to do with netChange.
@@ -194,43 +125,58 @@ void EthereumHost::maintainTransactions()
 	}
 	for (auto const& t: ts)
 		m_transactionsSent.insert(t.first);
-	for (auto p: peerSessions())
+	forEachPeerPtr([&](shared_ptr<EthereumPeer> _p)
-		if (auto ep = p.first->cap<EthereumPeer>())
+	{
+		bytes b;
+		unsigned n = 0;
+		for (auto const& h: peerTransactions[_p])
 		{
-			bytes b;
+			_p->m_knownTransactions.insert(h);
-			unsigned n = 0;
+			b += ts[h].rlp();
-			for (auto const& h: peerTransactions[ep])
+			++n;
-			{
+		}
-				ep->m_knownTransactions.insert(h);
-				b += ts[h].rlp();
-				++n;
-			}
 
-			ep->clearKnownTransactions();
+		_p->clearKnownTransactions();
 
-			if (n || ep->m_requireTransactions)
+		if (n || _p->m_requireTransactions)
-			{
+		{
-				RLPStream ts;
+			RLPStream ts;
-				ep->prep(ts, TransactionsPacket, n).appendRaw(b, n);
+			_p->prep(ts, TransactionsPacket, n).appendRaw(b, n);
-				ep->sealAndSend(ts);
+			_p->sealAndSend(ts);
-			}
-			ep->m_requireTransactions = false;
 		}
+		_p->m_requireTransactions = false;
+	});
+}
+
+void EthereumHost::forEachPeer(std::function<void(EthereumPeer*)> const& _f) const
+{
+	forEachPeerPtr([&](std::shared_ptr<EthereumPeer> _p)
+	{
+		if (_p)
+			_f(_p.get());
+	});
+}
+
+void EthereumHost::forEachPeerPtr(std::function<void(std::shared_ptr<EthereumPeer>)> const& _f) const
+{
+	for (auto s: peerSessions())
+		_f(s.first->cap<EthereumPeer>());
+	for (auto s: peerSessions(c_oldProtocolVersion)) //TODO: remove once v61+ is common
+		_f(s.first->cap<EthereumPeer>(c_oldProtocolVersion));
 }
 
 pair<vector<shared_ptr<EthereumPeer>>, vector<shared_ptr<EthereumPeer>>> EthereumHost::randomSelection(unsigned _percent, std::function<bool(EthereumPeer*)> const& _allow)
 {
 	pair<vector<shared_ptr<EthereumPeer>>, vector<shared_ptr<EthereumPeer>>> ret;
-	ret.second.reserve(peerSessions().size());
+	forEachPeerPtr([&](shared_ptr<EthereumPeer> _p)
-	for (auto const& j: peerSessions())
 	{
-		auto pp = j.first->cap<EthereumPeer>();
+		if (_p && _allow(_p.get()))
-		if (_allow(pp.get()))
+			ret.second.push_back(_p);
-			ret.second.push_back(pp);
+	});
-	}
 
-	ret.second.reserve((peerSessions().size() * _percent + 99) / 100);
+	size_t size = (ret.second.size() * _percent + 99) / 100;
-	for (unsigned i = (peerSessions().size() * _percent + 99) / 100; i-- && ret.second.size();)
+	ret.second.reserve(size);
+	for (unsigned i = size; i-- && ret.second.size();)
 	{
 		unsigned n = rand() % ret.second.size();
 		ret.first.push_back(std::move(ret.second[n]));
@@ -279,3 +225,434 @@ void EthereumHost::maintainBlocks(h256 const& _currentHash)
 		m_latestBlockSent = _currentHash;
 	}
 }
+
+void EthereumHost::onPeerStatus(EthereumPeer* _peer)
+{
+	Guard l(x_sync);
+	if (_peer->m_genesisHash != m_chain.genesisHash())
+		_peer->disable("Invalid genesis hash");
+	else if (_peer->m_protocolVersion != protocolVersion() && _peer->m_protocolVersion != c_oldProtocolVersion)
+		_peer->disable("Invalid protocol version.");
+	else if (_peer->m_networkId != networkId())
+		_peer->disable("Invalid network identifier.");
+	else if (_peer->session()->info().clientVersion.find("/v0.7.0/") != string::npos)
+		_peer->disable("Blacklisted client version.");
+	else if (isBanned(_peer->session()->id()))
+		_peer->disable("Peer banned for previous bad behaviour.");
+	else
+	{
+		if (_peer->m_protocolVersion != protocolVersion())
+			estimatePeerHashes(_peer);
+		else if (_peer->m_latestBlockNumber > m_chain.number())
+			_peer->m_expectedHashes = (unsigned)_peer->m_latestBlockNumber - m_chain.number();
+		if (m_hashMan.chainSize() < _peer->m_expectedHashes)
+			m_hashMan.resetToRange(m_chain.number() + 1, _peer->m_expectedHashes);
+		continueSync(_peer);
+	}
+}
+
+void EthereumHost::estimatePeerHashes(EthereumPeer* _peer)
+{
+	BlockInfo block = m_chain.info();
+	time_t lastBlockTime = (block.hash() == m_chain.genesisHash()) ? 1428192000 : (time_t)block.timestamp;
+	time_t now = time(0);
+	unsigned blockCount = 1000;
+	if (lastBlockTime > now)
+		clog(NetWarn) << "Clock skew? Latest block is in the future";
+	else
+		blockCount += (now - lastBlockTime) / (unsigned)c_durationLimit;
+	clog(NetAllDetail) << "Estimated hashes: " << blockCount;
+	_peer->m_expectedHashes = blockCount;
+}
+
+void EthereumHost::onPeerHashes(EthereumPeer* _peer, h256s const& _hashes)
+{
+	Guard l(x_sync);
+	assert(_peer->m_asking == Asking::Nothing);
+	onPeerHashes(_peer, _hashes, false);
+}
+
+void EthereumHost::onPeerHashes(EthereumPeer* _peer, h256s const& _hashes, bool _complete)
+{
+	if (_hashes.empty())
+	{
+		onPeerDoneHashes(_peer, true);
+		return;
+	}
+	unsigned knowns = 0;
+	unsigned unknowns = 0;
+	h256s neededBlocks;
+	for (unsigned i = 0; i < _hashes.size(); ++i)
+	{
+		_peer->addRating(1);
+		auto h = _hashes[i];
+		auto status = m_bq.blockStatus(h);
+		if (status == QueueStatus::Importing || status == QueueStatus::Ready || m_chain.isKnown(h))
+		{
+			clog(NetMessageSummary) << "block hash ready:" << h << ". Start blocks download...";
+			m_hashes += neededBlocks;
+			onPeerDoneHashes(_peer, true);
+			return;
+		}
+		else if (status == QueueStatus::Bad)
+		{
+			cwarn << "block hash bad!" << h << ". Bailing...";
+			_peer->setIdle();
+			return;
+		}
+		else if (status == QueueStatus::Unknown)
+		{
+			unknowns++;
+			neededBlocks.push_back(h);
+		}
+		else
+			knowns++;
+		m_syncingLatestHash = h;
+	}
+	m_hashes += neededBlocks;
+	clog(NetMessageSummary) << knowns << "knowns," << unknowns << "unknowns; now at" << m_syncingLatestHash;
+	if (_complete)
+	{
+		m_needSyncBlocks = true;
+		continueSync(_peer);
+	}
+	else if (m_hashes.size() > _peer->m_expectedHashes)
+	{
+		_peer->disable("Too many hashes");
+		m_hashes.clear();
+		m_syncingLatestHash = h256();
+		continueSync(); ///Try with some other peer, keep the chain
+	}
+	else
+		continueSync(_peer); /// Grab next hashes
+}
+
+void EthereumHost::onPeerHashes(EthereumPeer* _peer, unsigned /*_index*/, h256s const& _hashes)
+{
+	Guard l(x_sync);
+	assert(_peer->m_asking == Asking::Nothing);
+	if (_hashes.empty())
+	{
+		onPeerDoneHashes(_peer, true);
+		return;
+	}
+	unsigned knowns = 0;
+	unsigned unknowns = 0;
+	h256s neededBlocks;
+	for (unsigned i = 0; i < _hashes.size(); ++i)
+	{
+		_peer->addRating(1);
+		auto h = _hashes[i];
+		auto status = m_bq.blockStatus(h);
+		if (status == QueueStatus::Importing || status == QueueStatus::Ready || m_chain.isKnown(h))
+		{
+			clog(NetWarn) << "block hash already known:" << h;
+		}
+		else if (status == QueueStatus::Bad)
+		{
+			clog(NetWarn) << "block hash bad!" << h << ". Bailing...";
+			_peer->setIdle();
+			return;
+		}
+		else if (status == QueueStatus::Unknown)
+		{
+			unknowns++;
+			neededBlocks.push_back(h);
+		}
+		else
+			knowns++;
+	}
+	m_man.appendToChain(neededBlocks);
+	clog(NetMessageSummary) << knowns << "knowns," << unknowns << "unknowns";
+
+	if (m_hashMan.isComplete())
+	{
+		// Done our chain-get.
+		m_needSyncHashes = false;
+		clog(NetNote) << "Hashes download complete.";
+		// 1/100th for each useful block hash.
+		_peer->addRating(m_man.chainSize() / 100); //TODO: what about other peers?
+		m_hashMan.reset(m_chain.number() + 1);
+		continueSync();
+	}
+	else
+		continueSync(_peer);
+}
+
+void EthereumHost::onPeerDoneHashes(EthereumPeer* _peer, bool _localChain)
+{
+	assert(_peer->m_asking == Asking::Nothing);
+	m_needSyncHashes = false;
+	if (_peer->m_protocolVersion != protocolVersion() || _localChain)
+	{
+		m_man.resetToChain(m_hashes);
+		m_hashes.clear();
+	}
+	continueSync();
+}
+
+void EthereumHost::onPeerBlocks(EthereumPeer* _peer, RLP const& _r)
+{
+	Guard l(x_sync);
+	assert(_peer->m_asking == Asking::Nothing);
+	unsigned itemCount = _r.itemCount();
+	clog(NetMessageSummary) << "Blocks (" << dec << itemCount << "entries)" << (itemCount ? "" : ": NoMoreBlocks");
+
+	if (itemCount == 0)
+	{
+		// Got to this peer's latest block - just give up.
+		clog(NetNote) << "Finishing blocks fetch...";
+		// NOTE: need to notify of giving up on chain-hashes, too, altering state as necessary.
+		_peer->setIdle();
+		return;
+	}
+
+	unsigned success = 0;
+	unsigned future = 0;
+	unsigned unknown = 0;
+	unsigned got = 0;
+	unsigned repeated = 0;
+
+	for (unsigned i = 0; i < itemCount; ++i)
+	{
+		auto h = BlockInfo::headerHash(_r[i].data());
+		if (_peer->m_sub.noteBlock(h))
+		{
+			_peer->addRating(10);
+			switch (m_bq.import(_r[i].data(), m_chain))
+			{
+			case ImportResult::Success:
+				success++;
+				break;
+
+			case ImportResult::Malformed:
+			case ImportResult::BadChain:
+				_peer->disable("Malformed block received.");
+				return;
+
+			case ImportResult::FutureTime:
+				future++;
+				break;
+
+			case ImportResult::AlreadyInChain:
+			case ImportResult::AlreadyKnown:
+				got++;
+				break;
+
+			case ImportResult::UnknownParent:
+				unknown++;
+				break;
+
+			default:;
+			}
+		}
+		else
+		{
+			_peer->addRating(0);	// -1?
+			repeated++;
+		}
+	}
+
+	clog(NetMessageSummary) << dec << success << "imported OK," << unknown << "with unknown parents," << future << "with future timestamps," << got << " already known," << repeated << " repeats received.";
+
+	if (m_man.isComplete() && !m_needSyncHashes)
+	{
+		// Done our chain-get.
+		m_needSyncBlocks = false;
+		clog(NetNote) << "Chain download complete.";
+		// 1/100th for each useful block hash.
+		_peer->addRating(m_man.chainSize() / 100); //TODO: what about other peers?
+		m_man.reset();
+	}
+	continueSync(_peer);
+}
+
+void EthereumHost::onPeerNewHashes(EthereumPeer* _peer, h256s const& _hashes)
+{
+	Guard l(x_sync);
+	if (_peer->m_asking != Asking::Nothing)
+	{
+		clog(NetMessageSummary) << "Ignoring new hashes since we're already downloading.";
+		return;
+	}
+	clog(NetNote) << "New block hash discovered: syncing without help.";
+	onPeerHashes(_peer, _hashes, true);
+}
+
+void EthereumHost::onPeerNewBlock(EthereumPeer* _peer, RLP const& _r)
+{
+	Guard l(x_sync);
+	if (_peer->m_asking != Asking::Nothing)
+	{
+		clog(NetMessageSummary) << "Ignoring new blocks since we're already downloading.";
+		return;
+	}
+	auto h = BlockInfo::headerHash(_r[0].data());
+	clog(NetMessageSummary) << "NewBlock: " << h;
+
+	if (_r.itemCount() != 2)
+		_peer->disable("NewBlock without 2 data fields.");
+	else
+	{
+		bool sync = false;
+		switch (m_bq.import(_r[0].data(), m_chain))
+		{
+		case ImportResult::Success:
+			_peer->addRating(100);
+			break;
+		case ImportResult::FutureTime:
+			//TODO: Rating dependent on how far in future it is.
+			break;
+
+		case ImportResult::Malformed:
+		case ImportResult::BadChain:
+			_peer->disable("Malformed block received.");
+			return;
+
+		case ImportResult::AlreadyInChain:
+		case ImportResult::AlreadyKnown:
+			break;
+
+		case ImportResult::UnknownParent:
+			if (h)
+			{
+				u256 difficulty = _r[1].toInt<u256>();
+				if (m_syncingTotalDifficulty < difficulty)
+				{
+					clog(NetMessageSummary) << "Received block with no known parent. Resyncing...";
+					_peer->m_latestHash = h;
+					_peer->m_totalDifficulty = difficulty;
+					m_needSyncHashes = true;
+					m_needSyncBlocks = true;
+					m_syncingLatestHash = _peer->m_latestHash;
+					sync = true;
+				}
+			}
+			break;
+		default:;
+		}
+
+		DEV_GUARDED(_peer->x_knownBlocks)
+			_peer->m_knownBlocks.insert(h);
+
+		if (sync)
+			continueSync(_peer);
+	}
+}
+
+void EthereumHost::onPeerTransactions(EthereumPeer* _peer, RLP const& _r)
+{
+	unsigned itemCount = _r.itemCount();
+	clog(NetAllDetail) << "Transactions (" << dec << itemCount << "entries)";
+	Guard l(_peer->x_knownTransactions);
+	for (unsigned i = 0; i < itemCount; ++i)
+	{
+		auto h = sha3(_r[i].data());
+		_peer->m_knownTransactions.insert(h);
+		ImportResult ir = m_tq.import(_r[i].data());
+		switch (ir)
+		{
+		case ImportResult::Malformed:
+			_peer->addRating(-100);
+			break;
+		case ImportResult::AlreadyKnown:
+			// if we already had the transaction, then don't bother sending it on.
+			m_transactionsSent.insert(h);
+			_peer->addRating(0);
+			break;
+		case ImportResult::Success:
+			_peer->addRating(100);
+			break;
+		default:;
+		}
+	}
+}
+
+void EthereumHost::continueSync()
+{
+	clog(NetAllDetail) << "Getting help with downloading hashes and blocks";
+	forEachPeer([&](EthereumPeer* _p)
+	{
+		if (_p->m_asking == Asking::Nothing)
+			continueSync(_p);
+	});
+}
+
+void EthereumHost::continueSync(EthereumPeer* _peer)
+{
+	assert(_peer->m_asking == Asking::Nothing);
+	bool otherPeerSync = false;
+	if (m_needSyncHashes && peerShouldGrabChain(_peer))
+	{
+		forEachPeer([&](EthereumPeer* _p)
+		{
+			if (_p != _peer && _p->m_asking == Asking::Hashes && _p->m_protocolVersion != protocolVersion())
+				otherPeerSync = true; // Already have a peer downloading hash chain with old protocol, do nothing
+		});
+		if (otherPeerSync)
+		{
+			/// Downloading from other peer with v60 protocol, nothing ese we can do
+			_peer->setIdle();
+			return;
+		}
+		if (_peer->m_protocolVersion == protocolVersion() && !m_syncingLatestHash)
+			_peer->requestHashes(); /// v61+ and not catching up to a particular hash
+		else
+		{
+			// Restart/continue sync in single peer mode
+			if (!m_syncingLatestHash)
+			{
+				m_syncingLatestHash =_peer->m_latestHash;
+				m_syncingTotalDifficulty = _peer->m_totalDifficulty;
+			}
+			_peer->requestHashes(m_syncingLatestHash);
+		}
+	}
+	else if (m_needSyncBlocks && peerShouldGrabBlocks(_peer)) // Check if this peer can help with downloading blocks
+		_peer->requestBlocks();
+	else
+		_peer->setIdle();
+}
+
+bool EthereumHost::peerShouldGrabBlocks(EthereumPeer* _peer) const
+{
+	auto td = _peer->m_totalDifficulty;
+	auto lh = m_syncingLatestHash;
+	auto ctd = m_chain.details().totalDifficulty;
+
+	clog(NetAllDetail) << "Should grab blocks? " << td << "vs" << ctd;
+	if (td < ctd || (td == ctd && m_chain.currentHash() == lh))
+		return false;
+	return true;
+}
+
+bool EthereumHost::peerShouldGrabChain(EthereumPeer* _peer) const
+{
+	h256 c = m_chain.currentHash();
+	unsigned n = m_chain.number();
+	u256 td = m_chain.details().totalDifficulty;
+
+	clog(NetAllDetail) << "Attempt chain-grab? Latest:" << c << ", number:" << n << ", TD:" << td << " versus " << _peer->m_totalDifficulty;
+	if (td >= _peer->m_totalDifficulty)
+	{
+		clog(NetAllDetail) << "No. Our chain is better.";
+		return false;
+	}
+	else
+	{
+		clog(NetAllDetail) << "Yes. Their chain is better.";
+		return true;
+	}
+}
+
+bool EthereumHost::isSyncing() const
+{
+	Guard l(x_sync);
+	bool syncing = false;
+	forEachPeer([&](EthereumPeer* _p)
+	{
+		if (_p->m_asking != Asking::Nothing)
+			syncing = true;
+	});
+	return syncing;
+}

libethereum/EthereumHost.h

@@ -56,8 +56,6 @@ class BlockQueue;
  */
 class EthereumHost: public p2p::HostCapability<EthereumPeer>, Worker
 {
-	friend class EthereumPeer;
-
 public:
 	/// Start server, but don't listen.
 	EthereumHost(BlockChain const& _ch, TransactionQueue& _tq, BlockQueue& _bq, u256 _networkId);
@@ -72,21 +70,30 @@ public:
 	void reset();
 
 	DownloadMan const& downloadMan() const { return m_man; }
-	bool isSyncing() const { return !!m_syncer; }
+	bool isSyncing() const;
 
 	bool isBanned(p2p::NodeId _id) const { return !!m_banned.count(_id); }
 
 	void noteNewTransactions() { m_newTransactions = true; }
 	void noteNewBlocks() { m_newBlocks = true; }
 
-private:
+	void onPeerStatus(EthereumPeer* _peer); ///< Called by peer to report status
-	std::pair<std::vector<std::shared_ptr<EthereumPeer>>, std::vector<std::shared_ptr<EthereumPeer>>> randomSelection(unsigned _percent = 25, std::function<bool(EthereumPeer*)> const& _allow = [](EthereumPeer const*){ return true; });
+	void onPeerBlocks(EthereumPeer* _peer, RLP const& _r); ///< Called by peer once it has new blocks during syn
+	void onPeerNewBlock(EthereumPeer* _peer, RLP const& _r); ///< Called by peer once it has new blocks
+	void onPeerNewHashes(EthereumPeer* _peer, h256s const& _hashes); ///< Called by peer once it has new hashes
+	void onPeerHashes(EthereumPeer* _peer, h256s const& _hashes); ///< Called by peer once it has another sequential block of hashes during sync
+	void onPeerHashes(EthereumPeer* _peer, unsigned _index, h256s const& _hashes); ///< Called by peer once it has a new ordered block of hashes starting with a particular number
+	void onPeerTransactions(EthereumPeer* _peer, RLP const& _r); ///< Called by peer when it has new transactions
 
-	/// Session is tell us that we may need (re-)syncing with the peer.
+	DownloadMan& downloadMan() { return m_man; }
-	void noteNeedsSyncing(EthereumPeer* _who);
+	HashDownloadMan& hashDownloadMan() { return m_hashMan; }
+	BlockChain const& chain() { return m_chain; }
 
-	/// Called when the peer can no longer provide us with any needed blocks.
+	static unsigned const c_oldProtocolVersion;
-	void noteDoneBlocks(EthereumPeer* _who, bool _clemency);
+private:
+	std::pair<std::vector<std::shared_ptr<EthereumPeer>>, std::vector<std::shared_ptr<EthereumPeer>>> randomSelection(unsigned _percent = 25, std::function<bool(EthereumPeer*)> const& _allow = [](EthereumPeer const*){ return true; });
+	void forEachPeerPtr(std::function<void(std::shared_ptr<EthereumPeer>)> const& _f) const;
+	void forEachPeer(std::function<void(EthereumPeer*)> const& _f) const;
 
 	/// Sync with the BlockChain. It might contain one of our mined blocks, we might have new candidates from the network.
 	void doWork();
@@ -108,7 +115,13 @@ private:
 	virtual void onStarting() { startWorking(); }
 	virtual void onStopping() { stopWorking(); }
 
-	void changeSyncer(EthereumPeer* _ignore, bool _needHelp = true);
+	void continueSync(); /// Find something to do for all peers
+	void continueSync(EthereumPeer* _peer); /// Find some work to do for a peer
+	void onPeerDoneHashes(EthereumPeer* _peer, bool _new); /// Called when done downloading hashes from peer
+	void onPeerHashes(EthereumPeer* _peer, h256s const& _hashes, bool _complete);
+	bool peerShouldGrabBlocks(EthereumPeer* _peer) const;
+	bool peerShouldGrabChain(EthereumPeer* _peer) const;
+	void estimatePeerHashes(EthereumPeer* _peer);
 
 	BlockChain const& m_chain;
 	TransactionQueue& m_tq;					///< Maintains a list of incoming transactions not yet in a block on the blockchain.
@@ -116,9 +129,8 @@ private:
 
 	u256 m_networkId;
 
-	EthereumPeer* m_syncer = nullptr;	// TODO: switch to weak_ptr
-
 	DownloadMan m_man;
+	HashDownloadMan m_hashMan;
 
 	h256 m_latestBlockSent;
 	h256Hash m_transactionsSent;
@@ -127,6 +139,13 @@ private:
 
 	bool m_newTransactions = false;
 	bool m_newBlocks = false;
+
+	mutable Mutex x_sync;
+	bool m_needSyncHashes = true;				///< Indicates if need to downlad hashes
+	bool m_needSyncBlocks = true;				///< Indicates if we still need to download some blocks
+	h256 m_syncingLatestHash;					///< Latest block's hash, as of the current sync.
+	u256 m_syncingTotalDifficulty;				///< Latest block's total difficulty, as of the current sync.
+	h256s m_hashes;								///< List of hashes with unknown block numbers. Used for v60 chain downloading and catching up to a particular unknown
 };
 
 }

libethereum/EthereumPeer.cpp

@@ -34,11 +34,14 @@ using namespace dev;
 using namespace dev::eth;
 using namespace p2p;
 
-EthereumPeer::EthereumPeer(Session* _s, HostCapabilityFace* _h, unsigned _i):
+EthereumPeer::EthereumPeer(Session* _s, HostCapabilityFace* _h, unsigned _i, CapDesc const& _cap):
 	Capability(_s, _h, _i),
-	m_sub(host()->m_man)
+	m_sub(host()->downloadMan()),
+	m_hashSub(host()->hashDownloadMan()),
+	m_peerCapabilityVersion(_cap.second)
 {
-	transition(Asking::State);
+	m_syncHashNumber = host()->chain().number() + 1;
+	requestStatus();
 }
 
 EthereumPeer::~EthereumPeer()
@@ -50,7 +53,7 @@ EthereumPeer::~EthereumPeer()
 void EthereumPeer::abortSync()
 {
 	if (isSyncing())
-		transition(Asking::Nothing, true);
+		setIdle();
 }
 
 EthereumHost* EthereumPeer::host() const
@@ -74,161 +77,76 @@ string toString(Asking _a)
 	return "?";
 }
 
-void EthereumPeer::transition(Asking _a, bool _force, bool _needHelp)
-{
-	clog(NetMessageSummary) << "Transition!" << ::toString(_a) << "from" << ::toString(m_asking) << ", " << (isSyncing() ? "syncing" : "holding") << (needsSyncing() ? "& needed" : "");
 
-	if (m_asking == Asking::State && _a != Asking::State)
+void EthereumPeer::setIdle()
-		m_requireTransactions = true;
+{
+	m_sub.doneFetch();
+	m_hashSub.doneFetch();
+	setAsking(Asking::Nothing);
+}
 
+void EthereumPeer::requestStatus()
+{
+	if (m_asking != Asking::Nothing)
+	clog(NetWarn) << "Bad state: requesting state should be the first action";
+	setAsking(Asking::State);
 	RLPStream s;
+	bool latest = m_peerCapabilityVersion == host()->protocolVersion();
+	prep(s, StatusPacket, latest ? 6 : 5)
+					<< (latest ? host()->protocolVersion() : EthereumHost::c_oldProtocolVersion)
+					<< host()->networkId()
+					<< host()->chain().details().totalDifficulty
+					<< host()->chain().currentHash()
+					<< host()->chain().genesisHash();
+	if (latest)
+		s << u256(host()->chain().number());
+	sealAndSend(s);
+}
 
-	if (_a == Asking::State)
+void EthereumPeer::requestHashes()
-	{
+{
-		if (m_asking == Asking::Nothing)
+	if (m_asking == Asking::Blocks)
-		{
-			setAsking(Asking::State, false);
-			prep(s, StatusPacket, 5)
-							<< host()->protocolVersion()
-							<< host()->networkId()
-							<< host()->m_chain.details().totalDifficulty
-							<< host()->m_chain.currentHash()
-							<< host()->m_chain.genesisHash();
-			sealAndSend(s);
-			return;
-		}
-	}
-	else if (_a == Asking::Hashes)
-	{
-		if (m_asking == Asking::State || m_asking == Asking::Nothing)
-		{
-			if (isSyncing())
-				clog(NetWarn) << "Bad state: not asking for Hashes, yet syncing!";
-
-			m_syncingLatestHash = m_latestHash;
-			m_syncingTotalDifficulty = m_totalDifficulty;
-			resetNeedsSyncing();
-
-			setAsking(_a, true);
-			prep(s, GetBlockHashesPacket, 2) << m_syncingLatestHash << c_maxHashesAsk;
-			m_syncingNeededBlocks = h256s(1, m_syncingLatestHash);
-			sealAndSend(s);
-			return;
-		}
-		else if (m_asking == Asking::Hashes)
-		{
-			if (!isSyncing())
-				clog(NetWarn) << "Bad state: asking for Hashes yet not syncing!";
-
-			setAsking(_a, true);
-			prep(s, GetBlockHashesPacket, 2) << m_syncingLastReceivedHash << c_maxHashesAsk;
-			sealAndSend(s);
-			return;
-		}
-	}
-	else if (_a == Asking::Blocks)
-	{
-		if (m_asking == Asking::Hashes)
-		{
-			if (!isSyncing())
-				clog(NetWarn) << "Bad state: asking for Hashes yet not syncing!";
-			if (shouldGrabBlocks())
-			{
-				clog(NetNote) << "Difficulty of hashchain HIGHER. Grabbing" << m_syncingNeededBlocks.size() << "blocks [latest now" << m_syncingLatestHash << ", was" << host()->m_latestBlockSent << "]";
-
-				host()->m_man.resetToChain(m_syncingNeededBlocks);
-//				host()->m_latestBlockSent = m_syncingLatestHash;
-			}
-			else
-			{
-				clog(NetNote) << "Difficulty of hashchain not HIGHER. Ignoring.";
-				m_syncingLatestHash = h256();
-				setAsking(Asking::Nothing, false);
-				return;
-			}
-		}
-		// run through into...
-		if (m_asking == Asking::Nothing || m_asking == Asking::Hashes || m_asking == Asking::Blocks)
-		{
-			// Looks like it's the best yet for total difficulty. Set to download.
-			setAsking(Asking::Blocks, isSyncing(), _needHelp);		// will kick off other peers to help if available.
-			auto blocks = m_sub.nextFetch(c_maxBlocksAsk);
-			if (blocks.size())
-			{
-				prep(s, GetBlocksPacket, blocks.size());
-				for (auto const& i: blocks)
-					s << i;
-				sealAndSend(s);
-			}
-			else
-				transition(Asking::Nothing);
-			return;
-		}
-	}
-	else if (_a == Asking::Nothing)
-	{
-		if (m_asking == Asking::Blocks)
-		{
-			clog(NetNote) << "Finishing blocks fetch...";
-
-			// a bit overkill given that the other nodes may yet have the needed blocks, but better to be safe than sorry.
-			if (isSyncing())
-				host()->noteDoneBlocks(this, _force);
-
-			// NOTE: need to notify of giving up on chain-hashes, too, altering state as necessary.
-			m_sub.doneFetch();
-
-			setAsking(Asking::Nothing, false);
-		}
-		else if (m_asking == Asking::Hashes)
-		{
-			clog(NetNote) << "Finishing hashes fetch...";
-
-			setAsking(Asking::Nothing, false);
-		}
-		else if (m_asking == Asking::State)
-		{
-			setAsking(Asking::Nothing, false);
-			// Just got the state - should check to see if we can be of help downloading the chain if any.
-			// Otherwise, should put ourselves up for sync.
-			setNeedsSyncing(m_latestHash, m_totalDifficulty);
-		}
-		// Otherwise it's fine. We don't care if it's Nothing->Nothing.
 		return;
-	}
+	m_syncHashNumber = m_hashSub.nextFetch(c_maxHashesAsk);
-
+	setAsking(Asking::Hashes);
-	clog(NetWarn) << "Invalid state transition:" << ::toString(_a) << "from" << ::toString(m_asking) << ", " << (isSyncing() ? "syncing" : "holding") << (needsSyncing() ? "& needed" : "");
+	RLPStream s;
+	prep(s, GetBlockHashesByNumberPacket, 2) << m_syncHashNumber << c_maxHashesAsk;
+	sealAndSend(s);
 }
 
-void EthereumPeer::setAsking(Asking _a, bool _isSyncing, bool _needHelp)
+void EthereumPeer::requestHashes(h256 const& _lastHash)
 {
-	bool changedAsking = (m_asking != _a);
+	if (m_asking == Asking::Blocks)
-	m_asking = _a;
+		return;
-
+	setAsking(Asking::Hashes);
-	if (_isSyncing != (host()->m_syncer == this) || (_isSyncing && changedAsking))
+	RLPStream s;
-		host()->changeSyncer(_isSyncing ? this : nullptr, _needHelp);
+	prep(s, GetBlockHashesPacket, 2) << _lastHash << c_maxHashesAsk;
+	sealAndSend(s);
+}
 
-	if (!_isSyncing)
+void EthereumPeer::requestBlocks()
+{
+	setAsking(Asking::Blocks);
+	auto blocks = m_sub.nextFetch(c_maxBlocksAsk);
+	if (blocks.size())
 	{
-		m_syncingLatestHash = h256();
+		RLPStream s;
-		m_syncingTotalDifficulty = 0;
+		prep(s, GetBlocksPacket, blocks.size());
-		m_syncingNeededBlocks.clear();
+		for (auto const& i: blocks)
+			s << i;
+		sealAndSend(s);
 	}
-
+	else
-	m_lastAsk = chrono::system_clock::now();
+		setIdle();
-
+	return;
-	session()->addNote("ask", _a == Asking::Nothing ? "nothing" : _a == Asking::State ? "state" : _a == Asking::Hashes ? "hashes" : _a == Asking::Blocks ? "blocks" : "?");
-	session()->addNote("sync", string(isSyncing() ? "ongoing" : "holding") + (needsSyncing() ? " & needed" : ""));
 }
 
-void EthereumPeer::setNeedsSyncing(h256 _latestHash, u256 _td)
+void EthereumPeer::setAsking(Asking _a)
 {
-	m_latestHash = _latestHash;
+	m_asking = _a;
-	m_totalDifficulty = _td;
+	m_lastAsk = chrono::system_clock::now();
-
-	if (m_latestHash)
-		host()->noteNeedsSyncing(this);
 
+	session()->addNote("ask", _a == Asking::Nothing ? "nothing" : _a == Asking::State ? "state" : _a == Asking::Hashes ? "hashes" : _a == Asking::Blocks ? "blocks" : "?");
 	session()->addNote("sync", string(isSyncing() ? "ongoing" : "holding") + (needsSyncing() ? " & needed" : ""));
 }
 
@@ -241,57 +159,7 @@ void EthereumPeer::tick()
 
 bool EthereumPeer::isSyncing() const
 {
-	return host()->m_syncer == this;
+	return m_asking != Asking::Nothing;
-}
-
-bool EthereumPeer::shouldGrabBlocks() const
-{
-	auto td = m_syncingTotalDifficulty;
-	auto lh = m_syncingLatestHash;
-	auto ctd = host()->m_chain.details().totalDifficulty;
-
-	if (m_syncingNeededBlocks.empty())
-		return false;
-
-	clog(NetNote) << "Should grab blocks? " << td << "vs" << ctd << ";" << m_syncingNeededBlocks.size() << " blocks, ends" << m_syncingNeededBlocks.back();
-
-	if (td < ctd || (td == ctd && host()->m_chain.currentHash() == lh))
-		return false;
-
-	return true;
-}
-
-void EthereumPeer::attemptSync()
-{
-	if (m_asking != Asking::Nothing)
-	{
-		clog(NetAllDetail) << "Can't synced with this peer - outstanding asks.";
-		return;
-	}
-
-	// if already done this, then ignore.
-	if (!needsSyncing())
-	{
-		clog(NetAllDetail) << "Already synced with this peer.";
-		return;
-	}
-
-	h256 c = host()->m_chain.currentHash();
-	unsigned n = host()->m_chain.number();
-	u256 td = host()->m_chain.details().totalDifficulty;
-
-	clog(NetAllDetail) << "Attempt chain-grab? Latest:" << c << ", number:" << n << ", TD:" << td << " versus " << m_totalDifficulty;
-	if (td >= m_totalDifficulty)
-	{
-		clog(NetAllDetail) << "No. Our chain is better.";
-		resetNeedsSyncing();
-		transition(Asking::Nothing);
-	}
-	else
-	{
-		clog(NetAllDetail) << "Yes. Their chain is better.";
-		transition(Asking::Hashes);
-	}
 }
 
 bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
@@ -304,54 +172,23 @@ bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
 	{
 		m_protocolVersion = _r[0].toInt<unsigned>();
 		m_networkId = _r[1].toInt<u256>();
-
-		// a bit dirty as we're misusing these to communicate the values to transition, but harmless.
 		m_totalDifficulty = _r[2].toInt<u256>();
 		m_latestHash = _r[3].toHash<h256>();
-		auto genesisHash = _r[4].toHash<h256>();
+		m_genesisHash = _r[4].toHash<h256>();
-
+		if (m_peerCapabilityVersion == host()->protocolVersion())
-		clog(NetMessageSummary) << "Status:" << m_protocolVersion << "/" << m_networkId << "/" << genesisHash << ", TD:" << m_totalDifficulty << "=" << m_latestHash;
+		{
+			m_protocolVersion = host()->protocolVersion();
+			m_latestBlockNumber = _r[5].toInt<u256>();
+		}
 
-		if (genesisHash != host()->m_chain.genesisHash())
+		clog(NetMessageSummary) << "Status:" << m_protocolVersion << "/" << m_networkId << "/" << m_genesisHash << "/" << m_latestBlockNumber << ", TD:" << m_totalDifficulty << "=" << m_latestHash;
-			disable("Invalid genesis hash");
+		setAsking(Asking::Nothing);
-		else if (m_protocolVersion != host()->protocolVersion())
+		host()->onPeerStatus(this);
-			disable("Invalid protocol version.");
-		else if (m_networkId != host()->networkId())
-			disable("Invalid network identifier.");
-		else if (session()->info().clientVersion.find("/v0.7.0/") != string::npos)
-			disable("Blacklisted client version.");
-		else if (host()->isBanned(session()->id()))
-			disable("Peer banned for previous bad behaviour.");
-		else
-			transition(Asking::Nothing);
 		break;
 	}
 	case TransactionsPacket:
 	{
-		unsigned itemCount = _r.itemCount();
+		host()->onPeerTransactions(this, _r);
-		clog(NetAllDetail) << "Transactions (" << dec << itemCount << "entries)";
-		Guard l(x_knownTransactions);
-		for (unsigned i = 0; i < itemCount; ++i)
-		{
-			auto h = sha3(_r[i].data());
-			m_knownTransactions.insert(h);
-			ImportResult ir = host()->m_tq.import(_r[i].data());
-			switch (ir)
-			{
-			case ImportResult::Malformed:
-				addRating(-100);
-				break;
-			case ImportResult::AlreadyKnown:
-				// if we already had the transaction, then don't bother sending it on.
-				host()->m_transactionsSent.insert(h);
-				addRating(0);
-				break;
-			case ImportResult::Success:
-				addRating(100);
-				break;
-			default:;
-			}
-		}
 		break;
 	}
 	case GetBlockHashesPacket:
@@ -359,18 +196,39 @@ bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
 		h256 later = _r[0].toHash<h256>();
 		unsigned limit = _r[1].toInt<unsigned>();
 		clog(NetMessageSummary) << "GetBlockHashes (" << limit << "entries," << later << ")";
-
+		unsigned c = min<unsigned>(host()->chain().number(later), limit);
-		unsigned c = min<unsigned>(host()->m_chain.number(later), limit);
-
 		RLPStream s;
 		prep(s, BlockHashesPacket, c);
-		h256 p = host()->m_chain.details(later).parent;
+		h256 p = host()->chain().details(later).parent;
-		for (unsigned i = 0; i < c && p; ++i, p = host()->m_chain.details(p).parent)
+		for (unsigned i = 0; i < c && p; ++i, p = host()->chain().details(p).parent)
 			s << p;
 		sealAndSend(s);
 		addRating(0);
 		break;
 	}
+	case GetBlockHashesByNumberPacket:
+	{
+		u256 number256 = _r[0].toInt<u256>();
+		unsigned number = (unsigned) number256;
+		unsigned limit = _r[1].toInt<unsigned>();
+		clog(NetMessageSummary) << "GetBlockHashesByNumber (" << number << "-" << number + limit << ")";
+		RLPStream s;
+		if (number <= host()->chain().number())
+		{
+			unsigned c = min<unsigned>(host()->chain().number() - number + 1, limit);
+			prep(s, BlockHashesPacket, c);
+			for (unsigned n = number; n < number + c; n++)
+			{
+				h256 p = host()->chain().numberHash(n);
+				s << p;
+			}
+		}
+		else
+			prep(s, BlockHashesPacket, 0);
+		sealAndSend(s);
+		addRating(0);
+		break;
+	}
 	case BlockHashesPacket:
 	{
 		unsigned itemCount = _r.itemCount();
@@ -378,45 +236,22 @@ bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
 
 		if (m_asking != Asking::Hashes)
 		{
-			cwarn << "Peer giving us hashes when we didn't ask for them.";
+			clog(NetWarn) << "Peer giving us hashes when we didn't ask for them.";
 			break;
 		}
-		if (itemCount == 0)
+		setAsking(Asking::Nothing);
-		{
+		h256s hashes(itemCount);
-			transition(Asking::Blocks);
-			return true;
-		}
-		unsigned knowns = 0;
-		unsigned unknowns = 0;
 		for (unsigned i = 0; i < itemCount; ++i)
 		{
-			addRating(1);
+			hashes[i] = _r[i].toHash<h256>();
-			auto h = _r[i].toHash<h256>();
+			m_hashSub.noteHash(m_syncHashNumber + i, 1);
-			auto status = host()->m_bq.blockStatus(h);
-			if (status == QueueStatus::Importing || status == QueueStatus::Ready || host()->m_chain.isKnown(h))
-			{
-				clog(NetMessageSummary) << "block hash ready:" << h << ". Start blocks download...";
-				transition(Asking::Blocks);
-				return true;
-			}
-			else if (status == QueueStatus::Bad)
-			{
-				cwarn << "block hash bad!" << h << ". Bailing...";
-				transition(Asking::Nothing);
-				return true;
-			}
-			else if (status == QueueStatus::Unknown)
-			{
-				unknowns++;
-				m_syncingNeededBlocks.push_back(h);
-			}
-			else
-				knowns++;
-			m_syncingLastReceivedHash = h;
 		}
-		clog(NetMessageSummary) << knowns << "knowns," << unknowns << "unknowns; now at" << m_syncingLastReceivedHash;
+
-		// run through - ask for more.
+		if (m_protocolVersion == host()->protocolVersion())
-		transition(Asking::Hashes);
+			host()->onPeerHashes(this,  m_syncHashNumber, hashes); // V61+, report hashes by number
+		else
+			host()->onPeerHashes(this, hashes);
+		m_syncHashNumber += itemCount;
 		break;
 	}
 	case GetBlocksPacket:
@@ -436,9 +271,9 @@ bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
 		for (unsigned i = 0; i < min(count, c_maxBlocks); ++i)
 		{
 			auto h = _r[i].toHash<h256>();
-			if (host()->m_chain.isKnown(h))
+			if (host()->chain().isKnown(h))
 			{
-				rlp += host()->m_chain.block(_r[i].toHash<h256>());
+				rlp += host()->chain().block(_r[i].toHash<h256>());
 				++n;
 			}
 		}
@@ -455,157 +290,30 @@ bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
 	}
 	case BlocksPacket:
 	{
-		unsigned itemCount = _r.itemCount();
-		clog(NetMessageSummary) << "Blocks (" << dec << itemCount << "entries)" << (itemCount ? "" : ": NoMoreBlocks");
-
 		if (m_asking != Asking::Blocks)
-			clog(NetWarn) << "Unexpected Blocks received!";
+			clog(NetWarn) << "Peer giving us blocks when we didn't ask for them.";
-
+		else
-		if (itemCount == 0)
-		{
-			// Got to this peer's latest block - just give up.
-			transition(Asking::Nothing);
-			break;
-		}
-
-		unsigned success = 0;
-		unsigned future = 0;
-		unsigned unknown = 0;
-		unsigned got = 0;
-		unsigned repeated = 0;
-
-		for (unsigned i = 0; i < itemCount; ++i)
-		{
-			auto h = BlockInfo::headerHash(_r[i].data());
-			if (m_sub.noteBlock(h))
-			{
-				addRating(10);
-				switch (host()->m_bq.import(_r[i].data(), host()->m_chain))
-				{
-				case ImportResult::Success:
-					success++;
-					break;
-
-				case ImportResult::Malformed:
-				case ImportResult::BadChain:
-					disable("Malformed block received.");
-					return true;
-
-				case ImportResult::FutureTime:
-					future++;
-					break;
-
-				case ImportResult::AlreadyInChain:
-				case ImportResult::AlreadyKnown:
-					got++;
-					break;
-
-				case ImportResult::UnknownParent:
-					unknown++;
-					break;
-
-				default:;
-				}
-			}
-			else
-			{
-				addRating(0);	// -1?
-				repeated++;
-			}
-		}
-
-		clog(NetMessageSummary) << dec << success << "imported OK," << unknown << "with unknown parents," << future << "with future timestamps," << got << " already known," << repeated << " repeats received.";
-
-		if (m_asking == Asking::Blocks)
 		{
-			if (!got)
+			setAsking(Asking::Nothing);
-				transition(Asking::Blocks);
+			host()->onPeerBlocks(this, _r);
-			else
-				transition(Asking::Nothing);
 		}
 		break;
 	}
 	case NewBlockPacket:
 	{
-		auto h = BlockInfo::headerHash(_r[0].data());
+		host()->onPeerNewBlock(this, _r);
-		clog(NetMessageSummary) << "NewBlock: " << h;
-
-		if (_r.itemCount() != 2)
-			disable("NewBlock without 2 data fields.");
-		else
-		{
-			switch (host()->m_bq.import(_r[0].data(), host()->m_chain))
-			{
-			case ImportResult::Success:
-				addRating(100);
-				break;
-			case ImportResult::FutureTime:
-				//TODO: Rating dependent on how far in future it is.
-				break;
-
-			case ImportResult::Malformed:
-			case ImportResult::BadChain:
-				disable("Malformed block received.");
-				return true;
-
-			case ImportResult::AlreadyInChain:
-			case ImportResult::AlreadyKnown:
-				break;
-
-			case ImportResult::UnknownParent:
-				clog(NetMessageSummary) << "Received block with no known parent. Resyncing...";
-				setNeedsSyncing(h, _r[1].toInt<u256>());
-				break;
-			default:;
-			}
-
-			DEV_GUARDED(x_knownBlocks)
-				m_knownBlocks.insert(h);
-		}
 		break;
 	}
 	case NewBlockHashesPacket:
 	{
-		clog(NetMessageSummary) << "NewBlockHashes";
+		unsigned itemCount = _r.itemCount();
-		if (host()->isSyncing())
+		clog(NetMessageSummary) << "BlockHashes (" << dec << itemCount << "entries)" << (itemCount ? "" : ": NoMoreHashes");
-			clog(NetMessageSummary) << "Ignoring since we're already downloading.";
+
-		else
+		h256s hashes(itemCount);
-		{
+		for (unsigned i = 0; i < itemCount; ++i)
-			unsigned knowns = 0;
+			hashes[i] = _r[i].toHash<h256>();
-			unsigned unknowns = 0;
+
-			unsigned itemCount = _r.itemCount();
+		host()->onPeerNewHashes(this, hashes);
-			for (unsigned i = 0; i < itemCount; ++i)
-			{
-				addRating(1);
-				auto h = _r[i].toHash<h256>();
-				DEV_GUARDED(x_knownBlocks)
-					m_knownBlocks.insert(h);
-				auto status = host()->m_bq.blockStatus(h);
-				if (status == QueueStatus::Importing || status == QueueStatus::Ready || host()->m_chain.isKnown(h))
-					knowns++;
-				else if (status == QueueStatus::Bad)
-				{
-					cwarn << "block hash bad!" << h << ". Bailing...";
-					return true;
-				}
-				else if (status == QueueStatus::Unknown)
-				{
-					unknowns++;
-					m_syncingNeededBlocks.push_back(h);
-				}
-				else
-					knowns++;
-			}
-			clog(NetMessageSummary) << knowns << "knowns," << unknowns << "unknowns";
-			if (unknowns > 0)
-			{
-				clog(NetNote) << "Not syncing and new block hash discovered: syncing without help.";
-				host()->m_man.resetToChain(m_syncingNeededBlocks);
-				host()->changeSyncer(this, false);
-				transition(Asking::Blocks, false, false);	// TODO: transaction(Asking::NewBlocks, false)
-			}
-			return true;
-		}
 		break;
 	}
 	default:

libethereum/EthereumPeer.h

@@ -49,11 +49,11 @@ namespace eth
  */
 class EthereumPeer: public p2p::Capability
 {
-	friend class EthereumHost;
+	friend class EthereumHost; //TODO: remove this
 
 public:
 	/// Basic constructor.
-	EthereumPeer(p2p::Session* _s, p2p::HostCapabilityFace* _h, unsigned _i);
+	EthereumPeer(p2p::Session* _s, p2p::HostCapabilityFace* _h, unsigned _i, p2p::CapDesc const& _cap);
 
 	/// Basic destructor.
 	virtual ~EthereumPeer();
@@ -70,17 +70,26 @@ public:
 	/// What is the ethereum subprotocol host object.
 	EthereumHost* host() const;
 
+	/// Abort sync and reset fetch
+	void setIdle();
+
+	/// Request hashes. Uses hash download manager to get hash number. v61+ protocol version only
+	void requestHashes();
+
+	/// Request hashes for given parent hash.
+	void requestHashes(h256 const& _lastHash);
+
+	/// Request blocks. Uses block download manager.
+	void requestBlocks();
+
 private:
 	using p2p::Capability::sealAndSend;
 
 	/// Interpret an incoming message.
 	virtual bool interpret(unsigned _id, RLP const& _r);
 
-	/// Transition state in a particular direction.
+	/// Request status. Called from constructor
-	void transition(Asking _wantState, bool _force = false, bool _needHelp = true);
+	void requestStatus();
-
-	/// Attempt to begin syncing with this peer; first check the peer has a more difficlult chain to download, then start asking for hashes, then move to blocks.
-	void attemptSync();
 
 	/// Abort the sync operation.
 	void abortSync();
@@ -89,11 +98,7 @@ private:
 	void clearKnownTransactions() { std::lock_guard<std::mutex> l(x_knownTransactions); m_knownTransactions.clear(); }
 
 	/// Update our asking state.
-	void setAsking(Asking _g, bool _isSyncing, bool _needHelp = true);
+	void setAsking(Asking _g);
-
-	/// Update our syncing requirements state.
-	void setNeedsSyncing(h256 _latestHash, u256 _td);
-	void resetNeedsSyncing() { setNeedsSyncing(h256(), 0); }
 
 	/// Do we presently need syncing with this peer?
 	bool needsSyncing() const { return !!m_latestHash; }
@@ -101,14 +106,12 @@ private:
 	/// Are we presently syncing with this peer?
 	bool isSyncing() const;
 
-	/// Check whether the session should bother grabbing the peer's blocks.
-	bool shouldGrabBlocks() const;
-
 	/// Runs period checks to check up on the peer.
 	void tick();
 
 	/// Peer's protocol version.
 	unsigned m_protocolVersion;
+
 	/// Peer's network id.
 	u256 m_networkId;
 
@@ -117,24 +120,24 @@ private:
 	/// When we asked for it. Allows a time out.
 	std::chrono::system_clock::time_point m_lastAsk;
 
-	/// Whether this peer is in the process of syncing or not. Only one peer can be syncing at once.
-	bool m_isSyncing = false;
-
 	/// These are determined through either a Status message or from NewBlock.
 	h256 m_latestHash;						///< Peer's latest block's hash that we know about or default null value if no need to sync.
 	u256 m_totalDifficulty;					///< Peer's latest block's total difficulty.
-	/// Once a sync is started on this peer, they are cleared and moved into m_syncing*.
+	h256 m_genesisHash;						///< Peer's genesis hash
+	u256 m_latestBlockNumber;				///< Number of the latest block this peer has
 
 	/// This is built as we ask for hashes. Once no more hashes are given, we present this to the
 	/// host who initialises the DownloadMan and m_sub becomes active for us to begin asking for blocks.
-	h256s m_syncingNeededBlocks;				///< The blocks that we should download from this peer.
+	unsigned m_expectedHashes = 0;				///< Estimated upper bound of hashes to expect from this peer.
-	h256 m_syncingLastReceivedHash;				///< Hash most recently received from peer.
+	unsigned m_syncHashNumber = 0;				///< Number of latest hash we sync to
-	h256 m_syncingLatestHash;					///< Peer's latest block's hash, as of the current sync.
-	u256 m_syncingTotalDifficulty;				///< Peer's latest block's total difficulty, as of the current sync.
 
 	/// Once we're asking for blocks, this becomes in use.
 	DownloadSub m_sub;
 
+	/// Once we're asking for hashes, this becomes in use.
+	HashDownloadSub m_hashSub;
+
+	u256 m_peerCapabilityVersion;			///< Protocol version this peer supports received as capability
 	/// Have we received a GetTransactions packet that we haven't yet answered?
 	bool m_requireTransactions = false;
 
@@ -142,7 +145,6 @@ private:
 	h256Hash m_knownBlocks;					///< Blocks that the peer already knows about (that don't need to be sent to them).
 	Mutex x_knownTransactions;
 	h256Hash m_knownTransactions;			///< Transactions that the peer already knows of.
-
 };
 
 }

libp2p/Host.cpp

@@ -202,6 +202,10 @@ void Host::startPeerSession(Public const& _id, RLP const& _rlp, RLPXFrameIO* _io
 	// clang error (previously: ... << hex << caps ...)
 	// "'operator<<' should be declared prior to the call site or in an associated namespace of one of its arguments"
 	stringstream capslog;
+
+	if (caps.size() > 1)
+		caps.erase(remove_if(caps.begin(), caps.end(), [&](CapDesc const& _r){ return any_of(caps.begin(), caps.end(), [&](CapDesc const& _o){ return _r.first == _o.first && _o.second > _r.second; }); }), caps.end());
+
 	for (auto cap: caps)
 		capslog << "(" << cap.first << "," << dec << cap.second << ")";
 	clog(NetMessageSummary) << "Hello: " << clientVersion << "V[" << protocolVersion << "]" << _id << showbase << capslog.str() << dec << listenPort;
@@ -237,7 +241,7 @@ void Host::startPeerSession(Public const& _id, RLP const& _rlp, RLPXFrameIO* _io
 		for (auto const& i: caps)
 			if (haveCapability(i))
 			{
-				ps->m_capabilities[i] = shared_ptr<Capability>(m_capabilities[i]->newPeerCapability(ps.get(), o));
+				ps->m_capabilities[i] = shared_ptr<Capability>(m_capabilities[i]->newPeerCapability(ps.get(), o, i));
 				o += m_capabilities[i]->messageCount();
 			}
 		ps->start();

libp2p/Host.h

@@ -99,6 +99,7 @@ public:
 
 	/// Register a peer-capability; all new peer connections will have this capability.
 	template <class T> std::shared_ptr<T> registerCapability(T* _t) { _t->m_host = this; std::shared_ptr<T> ret(_t); m_capabilities[std::make_pair(T::staticName(), T::staticVersion())] = ret; return ret; }
+	template <class T> void addCapability(std::shared_ptr<T> const & _p, std::string const& _name, u256 const& _version) { m_capabilities[std::make_pair(_name, _version)] = _p; }
 
 	bool haveCapability(CapDesc const& _name) const { return m_capabilities.count(_name) != 0; }
 	CapDescs caps() const { CapDescs ret; for (auto const& i: m_capabilities) ret.push_back(i.first); return ret; }

libp2p/HostCapability.cpp

@@ -28,12 +28,17 @@ using namespace dev;
 using namespace dev::p2p;
 
 std::vector<std::pair<std::shared_ptr<Session>,std::shared_ptr<Peer>>> HostCapabilityFace::peerSessions() const
+{
+	return peerSessions(version());
+}
+
+std::vector<std::pair<std::shared_ptr<Session>,std::shared_ptr<Peer>>> HostCapabilityFace::peerSessions(u256 const& _version) const
 {
 	RecursiveGuard l(m_host->x_sessions);
 	std::vector<std::pair<std::shared_ptr<Session>,std::shared_ptr<Peer>>> ret;
 	for (auto const& i: m_host->m_sessions)
 		if (std::shared_ptr<Session> s = i.second.lock())
-			if (s->m_capabilities.count(capDesc()))
+			if (s->m_capabilities.count(std::make_pair(name(), _version)))
 				ret.push_back(make_pair(s,s->m_peer));
 	return ret;
 }

libp2p/HostCapability.h

@@ -46,13 +46,14 @@ public:
 	Host* host() const { return m_host; }
 
 	std::vector<std::pair<std::shared_ptr<Session>,std::shared_ptr<Peer>>> peerSessions() const;
+	std::vector<std::pair<std::shared_ptr<Session>,std::shared_ptr<Peer>>> peerSessions(u256 const& _version) const;
 
 protected:
 	virtual std::string name() const = 0;
 	virtual u256 version() const = 0;
 	CapDesc capDesc() const { return std::make_pair(name(), version()); }
 	virtual unsigned messageCount() const = 0;
-	virtual Capability* newPeerCapability(Session* _s, unsigned _idOffset) = 0;
+	virtual Capability* newPeerCapability(Session* _s, unsigned _idOffset, CapDesc const& _cap) = 0;
 
 	virtual void onStarting() {}
 	virtual void onStopping() {}
@@ -76,7 +77,7 @@ protected:
 	virtual std::string name() const { return PeerCap::name(); }
 	virtual u256 version() const { return PeerCap::version(); }
 	virtual unsigned messageCount() const { return PeerCap::messageCount(); }
-	virtual Capability* newPeerCapability(Session* _s, unsigned _idOffset) { return new PeerCap(_s, this, _idOffset); }
+	virtual Capability* newPeerCapability(Session* _s, unsigned _idOffset, CapDesc const& _cap) { return new PeerCap(_s, this, _idOffset, _cap); }
 };
 
 }

libp2p/Session.h

@@ -69,6 +69,8 @@ public:
 
 	template <class PeerCap>
 	std::shared_ptr<PeerCap> cap() const { try { return std::static_pointer_cast<PeerCap>(m_capabilities.at(std::make_pair(PeerCap::name(), PeerCap::version()))); } catch (...) { return nullptr; } }
+	template <class PeerCap>
+	std::shared_ptr<PeerCap> cap(u256 const& _version) const { try { return std::static_pointer_cast<PeerCap>(m_capabilities.at(std::make_pair(PeerCap::name(), _version))); } catch (...) { return nullptr; } }
 
 	static RLPStream& prep(RLPStream& _s, PacketType _t, unsigned _args = 0);
 	void sealAndSend(RLPStream& _s);

libwhisper/WhisperPeer.cpp

@@ -29,7 +29,7 @@ using namespace dev;
 using namespace dev::p2p;
 using namespace dev::shh;
 
-WhisperPeer::WhisperPeer(Session* _s, HostCapabilityFace* _h, unsigned _i): Capability(_s, _h, _i)
+WhisperPeer::WhisperPeer(Session* _s, HostCapabilityFace* _h, unsigned _i, CapDesc const&): Capability(_s, _h, _i)
 {
 	RLPStream s;
 	sealAndSend(prep(s, StatusPacket, 1) << version());

libwhisper/WhisperPeer.h

@@ -42,6 +42,7 @@ using p2p::Session;
 using p2p::HostCapabilityFace;
 using p2p::HostCapability;
 using p2p::Capability;
+using p2p::CapDesc;
 
 /**
  */
@@ -50,7 +51,7 @@ class WhisperPeer: public Capability
 	friend class WhisperHost;
 
 public:
-	WhisperPeer(Session* _s, HostCapabilityFace* _h, unsigned _i);
+	WhisperPeer(Session* _s, HostCapabilityFace* _h, unsigned _i, CapDesc const& _cap);
 	virtual ~WhisperPeer();
 
 	static std::string name() { return "shh"; }

test/libp2p/capability.cpp

@@ -49,7 +49,7 @@ struct VerbosityHolder
 class TestCapability: public Capability
 {
 public:
-	TestCapability(Session* _s, HostCapabilityFace* _h, unsigned _idOffset): Capability(_s, _h, _idOffset), m_cntReceivedMessages(0), m_testSum(0) {}
+	TestCapability(Session* _s, HostCapabilityFace* _h, unsigned _idOffset, CapDesc const&): Capability(_s, _h, _idOffset), m_cntReceivedMessages(0), m_testSum(0) {}
 	virtual ~TestCapability() {}
 	int countReceivedMessages() { return m_cntReceivedMessages; }
 	int testSum() { return m_testSum; }