mirror of
https://github.com/Xahau/xahaud.git
synced 2025-12-06 17:27:52 +00:00
319 lines
9.1 KiB
C++
319 lines
9.1 KiB
C++
|
|
#include "LedgerConsensus.h"
|
|
|
|
TransactionAcquire::TransactionAcquire(const uint256& hash) : PeerSet(hash, 1), mHaveRoot(false)
|
|
{
|
|
mMap = boost::make_shared<SHAMap>();
|
|
mMap->setSynching();
|
|
}
|
|
|
|
void TransactionAcquire::done()
|
|
{
|
|
// insert SHAMap in finished set (as valid or invalid), remove ourselves from current set
|
|
// WRITEME
|
|
}
|
|
|
|
boost::weak_ptr<PeerSet> TransactionAcquire::pmDowncast()
|
|
{
|
|
return boost::shared_polymorphic_downcast<PeerSet, TransactionAcquire>(shared_from_this());
|
|
}
|
|
|
|
void TransactionAcquire::trigger(Peer::pointer peer)
|
|
{
|
|
if (mComplete || mFailed)
|
|
return;
|
|
if (!mHaveRoot)
|
|
{
|
|
boost::shared_ptr<newcoin::TMGetLedger> tmGL = boost::make_shared<newcoin::TMGetLedger>();
|
|
tmGL->set_ledgerhash(mHash.begin(), mHash.size());
|
|
tmGL->set_itype(newcoin::liTS_CANDIDATE);
|
|
*(tmGL->add_nodeids()) = SHAMapNode().getRawString();
|
|
sendRequest(tmGL, peer);
|
|
}
|
|
if (mHaveRoot)
|
|
{
|
|
std::vector<SHAMapNode> nodeIDs;
|
|
std::vector<uint256> nodeHashes;
|
|
mMap->getMissingNodes(nodeIDs, nodeHashes, 256);
|
|
if (nodeIDs.empty())
|
|
{
|
|
if (mMap->isValid())
|
|
mComplete = true;
|
|
else
|
|
mFailed = true;
|
|
}
|
|
else
|
|
{
|
|
boost::shared_ptr<newcoin::TMGetLedger> tmGL = boost::make_shared<newcoin::TMGetLedger>();
|
|
tmGL->set_ledgerhash(mHash.begin(), mHash.size());
|
|
tmGL->set_itype(newcoin::liTS_CANDIDATE);
|
|
for (std::vector<SHAMapNode>::iterator it = nodeIDs.begin(); it != nodeIDs.end(); ++it)
|
|
*(tmGL->add_nodeids()) = it->getRawString();
|
|
if (peer)
|
|
sendRequest(tmGL, peer);
|
|
else
|
|
sendRequest(tmGL);
|
|
return;
|
|
}
|
|
}
|
|
if (mComplete || mFailed)
|
|
done();
|
|
else
|
|
resetTimer();
|
|
}
|
|
|
|
bool TransactionAcquire::takeNodes(const std::list<SHAMapNode>& nodeIDs,
|
|
const std::list< std::vector<unsigned char> >& data, Peer::pointer peer)
|
|
{
|
|
if (mComplete)
|
|
return true;
|
|
if (mFailed)
|
|
return false;
|
|
std::list<SHAMapNode>::const_iterator nodeIDit = nodeIDs.begin();
|
|
std::list< std::vector<unsigned char> >::const_iterator nodeDatait = data.begin();
|
|
while (nodeIDit != nodeIDs.end())
|
|
{
|
|
if (nodeIDit->isRoot())
|
|
{
|
|
if (!mMap->addRootNode(getHash(), *nodeDatait))
|
|
return false;
|
|
}
|
|
else if (!mMap->addKnownNode(*nodeIDit, *nodeDatait))
|
|
return false;
|
|
++nodeIDit;
|
|
++nodeDatait;
|
|
}
|
|
trigger(peer);
|
|
return true;
|
|
}
|
|
|
|
void LCTransaction::setVote(const uint256& peer, bool votesYes)
|
|
{
|
|
std::pair<boost::unordered_map<uint256, bool>::iterator, bool> res =
|
|
mVotes.insert(std::make_pair<uint256, bool>(peer, votesYes));
|
|
|
|
if (res.second)
|
|
{ // new vote
|
|
if (votesYes)
|
|
++mYays;
|
|
else
|
|
++mNays;
|
|
}
|
|
else if (votesYes && !res.first->second)
|
|
{ // changes vote to yes
|
|
--mNays;
|
|
++mYays;
|
|
res.first->second = true;
|
|
}
|
|
else if(!votesYes && !res.first->second)
|
|
{ // changes vote to no
|
|
++mNays;
|
|
--mYays;
|
|
res.first->second = false;
|
|
}
|
|
}
|
|
|
|
LedgerConsensus::LedgerConsensus(Ledger::pointer previousLedger)
|
|
: mState(lcsPRE_CLOSE), mPreviousLedger(previousLedger)
|
|
{
|
|
}
|
|
|
|
void LedgerConsensus::closeTime(Ledger::pointer& current)
|
|
{
|
|
if (mState != lcsPRE_CLOSE)
|
|
{
|
|
assert(false);
|
|
return;
|
|
}
|
|
CKey::pointer nodePrivKey = boost::make_shared<CKey>();
|
|
nodePrivKey->MakeNewKey(); // FIXME
|
|
|
|
current->updateHash();
|
|
uint256 txSet = current->getTransHash();
|
|
mOurPosition = boost::make_shared<LedgerProposal>(nodePrivKey, current->getParentHash(), txSet);
|
|
mapComplete(current->peekTransactionMap()->snapShot());
|
|
// WRITME: Broadcast an IHAVE for this set
|
|
}
|
|
|
|
void LedgerConsensus::mapComplete(SHAMap::pointer map)
|
|
{
|
|
boost::unordered_map<uint256, SHAMap::pointer>::iterator it = mComplete.find(map->getHash());
|
|
if (it != mComplete.end()) return; // we already have this map
|
|
|
|
if (mOurPosition && (map->getHash() != mOurPosition->getCurrentHash()))
|
|
{ // this could create disputed transactions
|
|
boost::unordered_map<uint256, SHAMap::pointer>::iterator it2 = mComplete.find(mOurPosition->getCurrentHash());
|
|
if (it2 != mComplete.end())
|
|
{
|
|
SHAMap::SHAMapDiff differences;
|
|
it2->second->compare(it->second, differences, 16384);
|
|
for(SHAMap::SHAMapDiff::iterator pos = differences.begin(), end = differences.end(); pos != end; ++pos)
|
|
{ // create disputed transactions
|
|
addDisputedTransaction(pos->first);
|
|
}
|
|
}
|
|
}
|
|
mComplete[map->getHash()] = map;
|
|
|
|
// Adjust tracking for each peer that takes this position
|
|
std::vector<uint256> peers;
|
|
for (boost::unordered_map<uint256, LedgerProposal::pointer>::iterator it = mPeerPositions.begin(),
|
|
end = mPeerPositions.end(); it != end; ++it)
|
|
{
|
|
if (it->second->getCurrentHash() == map->getHash())
|
|
peers.push_back(it->second->getPeerID());
|
|
}
|
|
if (!peers.empty())
|
|
adjustCount(map, peers);
|
|
}
|
|
|
|
void LedgerConsensus::adjustCount(SHAMap::pointer map, const std::vector<uint256>& peers)
|
|
{ // Adjust the counts on all disputed transactions based on the set of peers taking this position
|
|
for (boost::unordered_map<uint256, LCTransaction::pointer>::iterator it = mDisputes.begin(), end = mDisputes.end();
|
|
it != end; ++it)
|
|
{
|
|
bool setHas = map->hasItem(it->second->getTransactionID());
|
|
for(std::vector<uint256>::const_iterator pit = peers.begin(), pend = peers.end(); pit != pend; ++pit)
|
|
it->second->setVote(*pit, setHas);
|
|
}
|
|
}
|
|
|
|
void LedgerConsensus::abort()
|
|
{
|
|
mState = lcsABORTED;
|
|
}
|
|
|
|
int LedgerConsensus::startup()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
int LedgerConsensus::timerEntry()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
SHAMap::pointer LedgerConsensus::getTransactionTree(const uint256& hash, bool doAcquire)
|
|
{
|
|
boost::unordered_map<uint256, SHAMap::pointer>::iterator it = mComplete.find(hash);
|
|
if (it == mComplete.end())
|
|
{ // we have not completed acuiqiring this ledger
|
|
if (doAcquire)
|
|
{
|
|
TransactionAcquire::pointer& acquiring = mAcquiring[hash];
|
|
if (!acquiring)
|
|
{
|
|
acquiring = boost::make_shared<TransactionAcquire>(hash);
|
|
startAcquiring(acquiring);
|
|
}
|
|
}
|
|
return SHAMap::pointer();
|
|
}
|
|
return it->second;
|
|
}
|
|
|
|
void LedgerConsensus::startAcquiring(TransactionAcquire::pointer acquire)
|
|
{
|
|
boost::unordered_map< uint256, std::vector< boost::weak_ptr<Peer> > >::iterator it =
|
|
mPeerData.find(acquire->getHash());
|
|
|
|
if (it != mPeerData.end())
|
|
{ // Add any peers we already know have his transaction set
|
|
std::vector< boost::weak_ptr<Peer> >& peerList = it->second;
|
|
std::vector< boost::weak_ptr<Peer> >::iterator pit = peerList.begin();
|
|
while (pit != peerList.end())
|
|
{
|
|
Peer::pointer pr = pit->lock();
|
|
if (!pr)
|
|
pit = peerList.erase(pit);
|
|
else
|
|
{
|
|
acquire->peerHas(pr);
|
|
++pit;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void LedgerConsensus::addDisputedTransaction(const uint256& txID)
|
|
{
|
|
boost::unordered_map<uint256, LCTransaction::pointer>::iterator it = mDisputes.find(txID);
|
|
if (it != mDisputes.end()) return;
|
|
|
|
bool ourPosition = false;
|
|
if (mOurPosition)
|
|
{
|
|
boost::unordered_map<uint256, SHAMap::pointer>::iterator mit = mComplete.find(mOurPosition->getCurrentHash());
|
|
if (mit != mComplete.end())
|
|
ourPosition = mit->second->hasItem(txID);
|
|
else assert(false); // We don't have our own position?
|
|
}
|
|
|
|
LCTransaction::pointer txn = boost::make_shared<LCTransaction>(txID, ourPosition);
|
|
mDisputes[txID] = txn;
|
|
|
|
for (boost::unordered_map<uint256, LedgerProposal::pointer>::iterator pit = mPeerPositions.begin(),
|
|
pend = mPeerPositions.end(); pit != pend; ++pit)
|
|
{
|
|
boost::unordered_map<uint256, SHAMap::pointer>::const_iterator cit =
|
|
mComplete.find(pit->second->getCurrentHash());
|
|
if (cit != mComplete.end())
|
|
txn->setVote(pit->first, cit->second->hasItem(txID));
|
|
}
|
|
}
|
|
|
|
bool LedgerConsensus::peerPosition(LedgerProposal::pointer newPosition)
|
|
{
|
|
LedgerProposal::pointer& currentPosition = mPeerPositions[newPosition->getPeerID()];
|
|
if (currentPosition)
|
|
{
|
|
assert(newPosition->getPeerID() == currentPosition->getPeerID());
|
|
if (newPosition->getProposeSeq() <= currentPosition->getProposeSeq())
|
|
return false;
|
|
if (newPosition->getCurrentHash() == currentPosition->getCurrentHash())
|
|
{ // we missed an intermediary change
|
|
currentPosition = newPosition;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
currentPosition = newPosition;
|
|
SHAMap::pointer set = getTransactionTree(newPosition->getCurrentHash(), true);
|
|
if (set)
|
|
{
|
|
for (boost::unordered_map<uint256, LCTransaction::pointer>::iterator it = mDisputes.begin(),
|
|
end = mDisputes.end(); it != end; ++it)
|
|
it->second->setVote(newPosition->getPeerID(), set->hasItem(it->first));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool LedgerConsensus::peerHasSet(Peer::pointer peer, const std::vector<uint256>& sets)
|
|
{
|
|
for (std::vector<uint256>::const_iterator it = sets.begin(), end = sets.end(); it != end; ++it)
|
|
{
|
|
std::vector< boost::weak_ptr<Peer> >& set = mPeerData[*it];
|
|
bool found = false;
|
|
for (std::vector< boost::weak_ptr<Peer> >::iterator iit = set.begin(), iend = set.end(); iit != iend; ++iit)
|
|
if (iit->lock() == peer)
|
|
found = true;
|
|
if (!found)
|
|
{
|
|
set.push_back(peer);
|
|
boost::unordered_map<uint256, TransactionAcquire::pointer>::iterator acq = mAcquiring.find(*it);
|
|
if (acq != mAcquiring.end())
|
|
acq->second->peerHas(peer);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool LedgerConsensus::peerGaveNodes(Peer::pointer peer, const uint256& setHash,
|
|
const std::list<SHAMapNode>& nodeIDs, const std::list< std::vector<unsigned char> >& nodeData)
|
|
{
|
|
boost::unordered_map<uint256, TransactionAcquire::pointer>::iterator acq = mAcquiring.find(setHash);
|
|
if (acq == mAcquiring.end()) return false;
|
|
return acq->second->takeNodes(nodeIDs, nodeData, peer);
|
|
}
|