Move sources to src and build objs in obj.

src/LedgerMaster.cpp

@@ -0,0 +1,196 @@
+#include "LedgerMaster.h"
+#include "Application.h"
+#include "NewcoinAddress.h"
+#include "TimingService.h"
+#include "Conversion.h"
+#include <boost/foreach.hpp>
+
+LedgerMaster::LedgerMaster() : mIsSynced(false)
+{
+}
+
+uint32 LedgerMaster::getCurrentLedgerIndex()
+{
+	return mCurrentLedger->getLedgerSeq();
+}
+
+uint64 LedgerMaster::getBalance(const uint160& addr)
+{
+	return mCurrentLedger->getBalance(addr);
+}
+
+uint64 LedgerMaster::getBalance(std::string& addr)
+{
+	return mCurrentLedger->getBalance(humanTo160(addr));
+}
+
+bool LedgerMaster::addHeldTransaction(Transaction::pointer transaction)
+{ // returns true if transaction was added
+	boost::recursive_mutex::scoped_lock ml(mLock);
+	return mHeldTransactionsByID.insert(std::make_pair(transaction->getID(), transaction)).second;
+}
+
+void LedgerMaster::pushLedger(Ledger::pointer newLedger)
+{
+	ScopedLock sl(mLock);
+	if(!!mFinalizingLedger)
+	{
+		mFinalizingLedger->setClosed();
+		mFinalizingLedger->setAccepted();
+		mLedgerHistory.addAcceptedLedger(mFinalizingLedger);
+	}
+	mFinalizingLedger=mCurrentLedger;
+	mCurrentLedger=newLedger;
+}
+
+#if 0
+
+void LedgerMaster::startFinalization()
+{
+	mFinalizingLedger=mCurrentLedger;
+	mCurrentLedger=Ledger::pointer(new Ledger(mCurrentLedger->getIndex()+1));
+
+	applyFutureProposals( mFinalizingLedger->getIndex() );
+	applyFutureTransactions( mCurrentLedger->getIndex() );
+}
+
+void LedgerMaster::sendProposal()
+{
+	PackedMessage::pointer packet=Peer::createLedgerProposal(mFinalizingLedger);
+	theApp->getConnectionPool().relayMessage(NULL,packet);
+}
+
+
+void LedgerMaster::endFinalization()
+{
+	mFinalizingLedger->publishValidation();
+	mLedgerHistory.addAcceptedLedger(mFinalizingLedger);
+	mLedgerHistory.addLedger(mFinalizingLedger);
+
+	mFinalizingLedger=Ledger::pointer();
+}
+
+void LedgerMaster::addFutureProposal(Peer::pointer peer,newcoin::ProposeLedger& otherLedger)
+{
+	mFutureProposals.push_front(pair<Peer::pointer,newcoin::ProposeLedger>(peer,otherLedger));
+}
+
+void LedgerMaster::applyFutureProposals(uint32 ledgerIndex)
+{
+	for(list< pair<Peer::pointer,newcoin::ProposeLedger> >::iterator iter=mFutureProposals.begin(); iter !=mFutureProposals.end(); )
+	{
+		if( (*iter).second.ledgerindex() == ledgerIndex)
+		{
+			checkLedgerProposal((*iter).first,(*iter).second);
+			mFutureProposals.erase(iter);
+		}else iter++;
+	}
+}
+
+void LedgerMaster::applyFutureTransactions(uint32 ledgerIndex)
+{
+	for(list<TransactionPtr>::iterator iter=mFutureTransactions.begin(); iter !=mFutureTransactions.end(); )
+	{
+		if( (*iter)->ledgerindex() == ledgerIndex)
+		{
+			addTransaction(*iter);
+			mFutureTransactions.erase(iter);
+		}else iter++;
+	}
+}
+
+void LedgerMaster::checkLedgerProposal(Peer::pointer peer, newcoin::ProposeLedger& otherLedger)
+{
+	// see if this matches yours
+	// if you haven't finalized yet save it for when you do
+	// if doesn't match and you have <= transactions ask for the complete ledger
+	// if doesn't match and you have > transactions send your complete ledger
+	
+
+	if(otherLedger.ledgerindex()<mCurrentLedger->getIndex())
+	{
+		if( (!mFinalizingLedger) || 
+			otherLedger.ledgerindex()<mFinalizingLedger->getIndex())
+		{ // you have already closed this ledger
+			Ledger::pointer oldLedger=mLedgerHistory.getAcceptedLedger(otherLedger.ledgerindex());
+			if(oldLedger)
+			{
+				if( (oldLedger->getHash()!=protobufTo256(otherLedger.hash())) &&
+					(oldLedger->getNumTransactions()>=otherLedger.numtransactions()))
+				{
+					peer->sendLedgerProposal(oldLedger);
+				}
+			}
+		}else
+		{ // you guys are on the same page
+			uint256 otherHash=protobufTo256(otherLedger.hash());
+			if(mFinalizingLedger->getHash()!= otherHash)
+			{
+				if( mFinalizingLedger->getNumTransactions()>=otherLedger.numtransactions())
+				{
+					peer->sendLedgerProposal(mFinalizingLedger);
+				}else
+				{
+					peer->sendGetFullLedger(otherHash);
+				}
+			}
+		}
+	}else
+	{ // you haven't started finalizing this one yet save it for when you do
+		addFutureProposal(peer,otherLedger);
+	}
+}
+
+
+// TODO: optimize. this is expensive so limit the amount it is run
+void LedgerMaster::checkConsensus(uint32 ledgerIndex)
+{
+	Ledger::pointer ourAcceptedLedger=mLedgerHistory.getAcceptedLedger(ledgerIndex);
+	if(ourAcceptedLedger)
+	{
+		Ledger::pointer consensusLedger;
+		uint256 consensusHash;
+
+		if( theApp->getValidationCollection().getConsensusLedger(ledgerIndex,ourAcceptedLedger->getHash(), consensusLedger, consensusHash) )
+		{ // our accepted ledger isn't compatible with the consensus
+			if(consensusLedger)
+			{	// switch to this ledger. Re-validate
+				mLedgerHistory.addAcceptedLedger(consensusLedger);
+				consensusLedger->publishValidation();
+			}else
+			{	// we don't know the consensus one. Ask peers for it
+				// TODO: make sure this isn't sent many times before we have a chance to get a reply
+				PackedMessage::pointer msg=Peer::createGetFullLedger(consensusHash);
+				theApp->getConnectionPool().relayMessage(NULL,msg);
+			}
+		}
+	}
+}
+/*
+if( consensusHash && 
+(ourAcceptedLedger->getHash()!= *consensusHash))
+{
+Ledger::pointer consensusLedger=mLedgerHistory.getLedger(*consensusHash);
+if(consensusLedger)
+{ // see if these are compatible
+if(ourAcceptedLedger->isCompatible(consensusLedger))
+{	// try to merge any transactions from the consensus one into ours
+ourAcceptedLedger->mergeIn(consensusLedger);
+// Ledger::pointer child=ourAcceptedLedger->getChild();
+Ledger::pointer child=mLedgerHistory.getAcceptedLedger(ledgerIndex+1);
+if(child) child->recalculate();
+}else
+{ // switch to this ledger. Re-validate
+mLedgerHistory.addAcceptedLedger(consensusLedger);
+consensusLedger->publishValidation();
+}
+
+}else
+{	// we don't know the consensus one. Ask peers for it
+PackedMessage::pointer msg=Peer::createGetFullLedger(*consensusHash);
+theApp->getConnectionPool().relayMessage(NULL,msg);
+}
+}
+*/
+
+#endif