Merge branch 'master' of github.com:jedmccaleb/NewCoin

src/Ledger.h

@@ -260,7 +260,7 @@ public:
 	// Ripple functions : credit lines
 	//
 
-	// Index of node which is the ripple state between to accounts for a currency.
+	// Index of node which is the ripple state between two accounts for a currency.
 	static uint256 getRippleStateIndex(const NewcoinAddress& naA, const NewcoinAddress& naB, const uint160& uCurrency);
 	static uint256 getRippleStateIndex(const uint160& uiA, const uint160& uiB, const uint160& uCurrency)
 		{ return getRippleStateIndex(NewcoinAddress::createAccountID(uiA), NewcoinAddress::createAccountID(uiB), uCurrency); }

src/LedgerAcquire.cpp

@@ -11,14 +11,16 @@
 #include "HashPrefixes.h"
 
 // #define LA_DEBUG
-#define LEDGER_ACQUIRE_TIMEOUT 1
+#define LEDGER_ACQUIRE_TIMEOUT 750
 #define TRUST_NETWORK
 
 PeerSet::PeerSet(const uint256& hash, int interval) : mHash(hash), mTimerInterval(interval), mTimeouts(0),
 	mComplete(false), mFailed(false), mProgress(true), mTimer(theApp->getIOService())
-{ ; }
+{
+	assert((mTimerInterval > 10) && (mTimerInterval < 30000));
+}
 
-void PeerSet::peerHas(Peer::pointer ptr)
+void PeerSet::peerHas(const Peer::pointer& ptr)
 {
 	boost::recursive_mutex::scoped_lock sl(mLock);
 	std::vector< boost::weak_ptr<Peer> >::iterator it = mPeers.begin();
@@ -38,7 +40,7 @@ void PeerSet::peerHas(Peer::pointer ptr)
 	newPeer(ptr);
 }
 
-void PeerSet::badPeer(Peer::pointer ptr)
+void PeerSet::badPeer(const Peer::pointer& ptr)
 {
 	boost::recursive_mutex::scoped_lock sl(mLock);
 	std::vector< boost::weak_ptr<Peer> >::iterator it = mPeers.begin();
@@ -61,7 +63,7 @@ void PeerSet::badPeer(Peer::pointer ptr)
 
 void PeerSet::resetTimer()
 {
-	mTimer.expires_from_now(boost::posix_time::seconds(mTimerInterval));
+	mTimer.expires_from_now(boost::posix_time::milliseconds(mTimerInterval));
 	mTimer.async_wait(boost::bind(&PeerSet::TimerEntry, pmDowncast(), boost::asio::placeholders::error));
 }
 
@@ -140,7 +142,7 @@ void LedgerAcquire::addOnComplete(boost::function<void (LedgerAcquire::pointer)>
 	mLock.unlock();
 }
 
-void LedgerAcquire::trigger(Peer::pointer peer, bool timer)
+void LedgerAcquire::trigger(const Peer::pointer& peer, bool timer)
 {
 	if (mAborted || mComplete || mFailed)
 		return;
@@ -433,7 +435,7 @@ void LedgerAcquireMaster::dropLedger(const uint256& hash)
 	mLedgers.erase(hash);
 }
 
-bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::pointer peer)
+bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, const Peer::pointer& peer)
 {
 #ifdef LA_DEBUG
 	Log(lsTRACE) << "got data for acquiring ledger ";

src/LedgerAcquire.h

@@ -41,12 +41,12 @@ public:
 
 	void progress()						{ mProgress = true; }
 
-	void peerHas(Peer::pointer);
-	void badPeer(Peer::pointer);
+	void peerHas(const Peer::pointer&);
+	void badPeer(const Peer::pointer&);
 	void resetTimer();
 
 protected:
-	virtual void newPeer(Peer::pointer) = 0;
+	virtual void newPeer(const Peer::pointer&) = 0;
 	virtual void onTimer(void) = 0;
 	virtual boost::weak_ptr<PeerSet> pmDowncast() = 0;
 
@@ -72,7 +72,7 @@ protected:
 	void done();
 	void onTimer();
 
-	void newPeer(Peer::pointer peer) { trigger(peer, false); }
+	void newPeer(const Peer::pointer& peer) { trigger(peer, false); }
 
 	boost::weak_ptr<PeerSet> pmDowncast();
 
@@ -92,7 +92,7 @@ public:
 	bool takeTxRootNode(const std::vector<unsigned char>& data);
 	bool takeAsNode(const std::list<SHAMapNode>& IDs, const std::list<std::vector<unsigned char> >& data);
 	bool takeAsRootNode(const std::vector<unsigned char>& data);
-	void trigger(Peer::pointer, bool timer);
+	void trigger(const Peer::pointer&, bool timer);
 };
 
 class LedgerAcquireMaster
@@ -108,7 +108,7 @@ public:
 	LedgerAcquire::pointer find(const uint256& hash);
 	bool hasLedger(const uint256& ledgerHash);
 	void dropLedger(const uint256& ledgerHash);
-	bool gotLedgerData(newcoin::TMLedgerData& packet, Peer::pointer);
+	bool gotLedgerData(newcoin::TMLedgerData& packet, const Peer::pointer&);
 };
 
 #endif

src/LedgerConsensus.cpp

@@ -13,11 +13,13 @@
 #include "Log.h"
 #include "SHAMapSync.h"
 
+#define TX_ACQUIRE_TIMEOUT	250
+
 #define TRUST_NETWORK
 
 // #define LC_DEBUG
 
-TransactionAcquire::TransactionAcquire(const uint256& hash) : PeerSet(hash, 1), mHaveRoot(false)
+TransactionAcquire::TransactionAcquire(const uint256& hash) : PeerSet(hash, TX_ACQUIRE_TIMEOUT), mHaveRoot(false)
 {
 	mMap = boost::make_shared<SHAMap>();
 	mMap->setSynching();
@@ -39,7 +41,7 @@ boost::weak_ptr<PeerSet> TransactionAcquire::pmDowncast()
 	return boost::shared_polymorphic_downcast<PeerSet, TransactionAcquire>(shared_from_this());
 }
 
-void TransactionAcquire::trigger(Peer::pointer peer, bool timer)
+void TransactionAcquire::trigger(const Peer::pointer& peer, bool timer)
 {
 	if (mComplete || mFailed)
 		return;
@@ -664,6 +666,7 @@ void LedgerConsensus::startAcquiring(TransactionAcquire::pointer acquire)
 			}
 		}
 	}
+	acquire->resetTimer();
 }
 
 void LedgerConsensus::propose(const std::vector<uint256>& added, const std::vector<uint256>& removed)

src/LedgerConsensus.h

@@ -27,11 +27,11 @@ protected:
 	SHAMap::pointer		mMap;
 	bool				mHaveRoot;
 
-	void onTimer()						{ trigger(Peer::pointer(), true); }
-	void newPeer(Peer::pointer peer)	{ trigger(peer, false); }
+	void onTimer()							{ trigger(Peer::pointer(), true); }
+	void newPeer(const Peer::pointer& peer)	{ trigger(peer, false); }
 
 	void done();
-	void trigger(Peer::pointer, bool timer);
+	void trigger(const Peer::pointer&, bool timer);
 	boost::weak_ptr<PeerSet> pmDowncast();
 
 public:

src/LedgerEntrySet.cpp

@@ -61,7 +61,7 @@ LedgerEntryAction LedgerEntrySet::hasEntry(const uint256& index) const
 	return it->second.mAction;
 }
 
-void LedgerEntrySet::entryCache(SLE::pointer& sle)
+void LedgerEntrySet::entryCache(const SLE::pointer& sle)
 {
 	boost::unordered_map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find(sle->getIndex());
 	if (it == mEntries.end())
@@ -82,7 +82,7 @@ void LedgerEntrySet::entryCache(SLE::pointer& sle)
 	}
 }
 
-void LedgerEntrySet::entryCreate(SLE::pointer& sle)
+void LedgerEntrySet::entryCreate(const SLE::pointer& sle)
 {
 	boost::unordered_map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find(sle->getIndex());
 	if (it == mEntries.end())
@@ -112,7 +112,7 @@ void LedgerEntrySet::entryCreate(SLE::pointer& sle)
 	}
 }
 
-void LedgerEntrySet::entryModify(SLE::pointer& sle)
+void LedgerEntrySet::entryModify(const SLE::pointer& sle)
 {
 	boost::unordered_map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find(sle->getIndex());
 	if (it == mEntries.end())
@@ -147,7 +147,7 @@ void LedgerEntrySet::entryModify(SLE::pointer& sle)
 	}
  }
 
-void LedgerEntrySet::entryDelete(SLE::pointer& sle, bool unfunded)
+void LedgerEntrySet::entryDelete(const SLE::pointer& sle, bool unfunded)
 {
 	boost::unordered_map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find(sle->getIndex());
 	if (it == mEntries.end())

src/LedgerEntrySet.h

@@ -23,7 +23,7 @@ public:
 	LedgerEntryAction	mAction;
 	int					mSeq;
 
-	LedgerEntrySetEntry(SLE::pointer e, LedgerEntryAction a, int s) : mEntry(e), mAction(a), mSeq(s) { ; }
+	LedgerEntrySetEntry(const SLE::pointer& e, LedgerEntryAction a, int s) : mEntry(e), mAction(a), mSeq(s) { ; }
 };
 
 
@@ -53,10 +53,10 @@ public:
 	// basic entry functions
 	SLE::pointer getEntry(const uint256& index, LedgerEntryAction&);
 	LedgerEntryAction hasEntry(const uint256& index) const;
-	void entryCache(SLE::pointer&);			// Add this entry to the cache
-	void entryCreate(SLE::pointer&);		// This entry will be created
-	void entryDelete(SLE::pointer&, bool unfunded);
-	void entryModify(SLE::pointer&);		// This entry will be modified
+	void entryCache(const SLE::pointer&);		// Add this entry to the cache
+	void entryCreate(const SLE::pointer&);		// This entry will be created
+	void entryDelete(const SLE::pointer&, bool unfunded);
+	void entryModify(const SLE::pointer&);		// This entry will be modified
 
 	Json::Value getJson(int) const;
 	void addRawMeta(Serializer&);

src/NetworkOPs.cpp

@@ -292,15 +292,6 @@ Json::Value NetworkOPs::getOwnerInfo(Ledger::pointer lpLedger, const NewcoinAddr
 	return jvObjects;
 }
 
-//
-// Ripple functions
-//
-
-RippleState::pointer NetworkOPs::accessRippleState(const uint256& uLedger, const uint256& uIndex)
-{
-	return mLedgerMaster->getLedgerByHash(uLedger)->accessRippleState(uIndex);
-}
-
 //
 // Other
 //

src/NetworkOPs.h

@@ -145,21 +145,7 @@ public:
 	Json::Value getOwnerInfo(const uint256& uLedger, const NewcoinAddress& naAccount);
 	Json::Value getOwnerInfo(Ledger::pointer lpLedger, const NewcoinAddress& naAccount);
 
-	//
-	// Ripple functions
-	//
-
-	bool					getDirLineInfo(const uint256& uLedger, const NewcoinAddress& naAccount, uint256& uRootIndex)
-		{
-			LedgerStateParms	lspNode		= lepNONE;
-
-			uRootIndex	= Ledger::getRippleDirIndex(naAccount.getAccountID());
-
-			return !!mLedgerMaster->getLedgerByHash(uLedger)->getDirNode(lspNode, uRootIndex);
-		}
-
-	RippleState::pointer	accessRippleState(const uint256& uLedger, const uint256& uIndex);
-
+	
 	// raw object operations
 	bool findRawLedger(const uint256& ledgerHash, std::vector<unsigned char>& rawLedger);
 	bool findRawTransaction(const uint256& transactionHash, std::vector<unsigned char>& rawTransaction);

src/Peer.cpp

@@ -260,7 +260,7 @@ void Peer::connected(const boost::system::error_code& error)
 	}
 }
 
-void Peer::sendPacketForce(PackedMessage::pointer packet)
+void Peer::sendPacketForce(const PackedMessage::pointer& packet)
 {
 	if (!mDetaching)
 	{
@@ -273,7 +273,7 @@ void Peer::sendPacketForce(PackedMessage::pointer packet)
 	}
 }
 
-void Peer::sendPacket(PackedMessage::pointer packet)
+void Peer::sendPacket(const PackedMessage::pointer& packet)
 {
 	if (packet)
 	{
@@ -1214,7 +1214,8 @@ Json::Value Peer::getJson()
 	//ret["this"]			= ADDRESS(this);
 	ret["public_key"]	= mNodePublic.ToString();
 	ret["ip"]			= mIpPortConnect.first;
-	ret["port"]			= mIpPortConnect.second;
+	//ret["port"]			= mIpPortConnect.second;
+	ret["port"]			= mIpPort.second;
 
 	if (mHello.has_fullversion())
 		ret["version"] = mHello.fullversion();

src/Peer.h

@@ -30,7 +30,7 @@ public:
 	static const int psbNoLedgers = 4, psbNoTransactions = 5, psbDownLevel = 6;
 
 	void			handleConnect(const boost::system::error_code& error, boost::asio::ip::tcp::resolver::iterator it);
-	static void		sHandleConnect(Peer::pointer ptr, const boost::system::error_code& error,
+	static void		sHandleConnect(const Peer::pointer& ptr, const boost::system::error_code& error,
 		boost::asio::ip::tcp::resolver::iterator it)
 	{ ptr->handleConnect(error, it); }
 
@@ -52,11 +52,11 @@ private:
 	boost::asio::deadline_timer									mVerifyTimer;
 
 	void			handleStart(const boost::system::error_code& ecResult);
-	static void		sHandleStart(Peer::pointer ptr, const boost::system::error_code& ecResult)
+	static void		sHandleStart(const Peer::pointer& ptr, const boost::system::error_code& ecResult)
 	{ ptr->handleStart(ecResult); }
 
 	void			handleVerifyTimer(const boost::system::error_code& ecResult);
-	static void		sHandleVerifyTimer(Peer::pointer ptr, const boost::system::error_code& ecResult)
+	static void		sHandleVerifyTimer(const Peer::pointer& ptr, const boost::system::error_code& ecResult)
 	{ ptr->handleVerifyTimer(ecResult); }
 
 protected:
@@ -70,26 +70,26 @@ protected:
 	Peer(boost::asio::io_service& io_service, boost::asio::ssl::context& ctx);
 
 	void handleShutdown(const boost::system::error_code& error) { ; }
-	static void sHandleShutdown(Peer::pointer ptr, const boost::system::error_code& error)
+	static void sHandleShutdown(const Peer::pointer& ptr, const boost::system::error_code& error)
 	{ ptr->handleShutdown(error); }
 
 	void handle_write(const boost::system::error_code& error, size_t bytes_transferred);
-	static void sHandle_write(Peer::pointer ptr, const boost::system::error_code& error, size_t bytes_transferred)
+	static void sHandle_write(const Peer::pointer& ptr, const boost::system::error_code& error, size_t bytes_transferred)
 	{ ptr->handle_write(error, bytes_transferred); }
 
 	void handle_read_header(const boost::system::error_code& error);
-	static void sHandle_read_header(Peer::pointer ptr, const boost::system::error_code& error)
+	static void sHandle_read_header(const Peer::pointer& ptr, const boost::system::error_code& error)
 	{ ptr->handle_read_header(error); }
 
 	void handle_read_body(const boost::system::error_code& error);
-	static void sHandle_read_body(Peer::pointer ptr, const boost::system::error_code& error)
+	static void sHandle_read_body(const Peer::pointer& ptr, const boost::system::error_code& error)
 	{ ptr->handle_read_body(error); }
 
 	void processReadBuffer();
 	void start_read_header();
 	void start_read_body(unsigned msg_len);
 
-	void sendPacketForce(PackedMessage::pointer packet);
+	void sendPacketForce(const PackedMessage::pointer& packet);
 
 	void sendHello();
 
@@ -139,12 +139,12 @@ public:
 	void connect(const std::string strIp, int iPort);
 	void connected(const boost::system::error_code& error);
 	void detach(const char *);
-	bool samePeer(Peer::pointer p) { return samePeer(*p); }
-	bool samePeer(const Peer& p) { return this == &p; }
+	bool samePeer(const Peer::pointer& p)	{ return samePeer(*p); }
+	bool samePeer(const Peer& p)			{ return this == &p; }
 
-	void sendPacket(PackedMessage::pointer packet);
-	void sendLedgerProposal(Ledger::pointer ledger);
-	void sendFullLedger(Ledger::pointer ledger);
+	void sendPacket(const PackedMessage::pointer& packet);
+	void sendLedgerProposal(const Ledger::pointer& ledger);
+	void sendFullLedger(const Ledger::pointer& ledger);
 	void sendGetFullLedger(uint256& hash);
 	void sendGetPeers();
 
@@ -153,11 +153,6 @@ public:
 	Json::Value getJson();
 	bool isConnected() const { return mHelloed && !mDetaching; }
 
-	//static PackedMessage::pointer createFullLedger(Ledger::pointer ledger);
-	static PackedMessage::pointer createLedgerProposal(Ledger::pointer ledger);
-	static PackedMessage::pointer createValidation(Ledger::pointer ledger);
-	static PackedMessage::pointer createGetFullLedger(uint256& hash);
-
 	uint256 getClosedLedgerHash() const { return mClosedLedgerHash; }
 	bool hasLedger(const uint256& hash) const;
 	NewcoinAddress getNodePublic() const { return mNodePublic; }

src/RPCServer.cpp

@@ -12,6 +12,7 @@
 #include "NicknameState.h"
 #include "utils.h"
 #include "Log.h"
+#include "RippleLines.h"
 
 #include <iostream>
 
@@ -1657,70 +1658,27 @@ Json::Value RPCServer::doRippleLinesGet(const Json::Value &params)
 
 		// XXX This is wrong, we do access the current ledger and do need to worry about changes.
 		// We access a committed ledger and need not worry about changes.
-		uint256	uRootIndex;
 
-		if (mNetOps->getDirLineInfo(uCurrent, naAccount, uRootIndex))
+		RippleLines rippleLines(naAccount.getAccountID());
+		BOOST_FOREACH(RippleState::pointer line,rippleLines.getLines())
 		{
-			Log(lsINFO) << "doRippleLinesGet: dir root index: " << uRootIndex.ToString();
-			bool	bDone	= false;
+			STAmount		saBalance	= line->getBalance();
+			STAmount		saLimit		= line->getLimit();
+			STAmount		saLimitPeer	= line->getLimitPeer();
 
-			while (!bDone)
-			{
-				uint64		uNodePrevious;
-				uint64		uNodeNext;
-				STVector256	svRippleNodes	= mNetOps->getDirNodeInfo(uCurrent, uRootIndex, uNodePrevious, uNodeNext);
+			Json::Value			jPeer	= Json::Value(Json::objectValue);
 
-				Log(lsINFO) << "doRippleLinesGet: previous: " << strHex(uNodePrevious);
-				Log(lsINFO) << "doRippleLinesGet:     next: " << strHex(uNodeNext);
-				Log(lsINFO) << "doRippleLinesGet:    lines: " << svRippleNodes.peekValue().size();
+			//jPeer["node"]		= uNode.ToString();
 
-				BOOST_FOREACH(uint256& uNode, svRippleNodes.peekValue())
-				{
-					Log(lsINFO) << "doRippleLinesGet: line index: " << uNode.ToString();
+			jPeer["account"]	= line->getAccountIDPeer().humanAccountID();
+			// Amount reported is positive if current account holds other account's IOUs.
+			// Amount reported is negative if other account holds current account's IOUs.
+			jPeer["balance"]	= saBalance.getText();
+			jPeer["currency"]	= saBalance.getHumanCurrency();
+			jPeer["limit"]		= saLimit.getText();
+			jPeer["limit_peer"]	= saLimitPeer.getText();
 
-					RippleState::pointer	rsLine	= mNetOps->accessRippleState(uCurrent, uNode);
-
-					if (rsLine)
-					{
-						rsLine->setViewAccount(naAccount);
-
-						STAmount		saBalance	= rsLine->getBalance();
-						STAmount		saLimit		= rsLine->getLimit();
-						STAmount		saLimitPeer	= rsLine->getLimitPeer();
-
-						Json::Value			jPeer	= Json::Value(Json::objectValue);
-
-						jPeer["node"]		= uNode.ToString();
-
-						jPeer["account"]	= rsLine->getAccountIDPeer().humanAccountID();
-						// Amount reported is positive if current account hold's other account's IOUs.
-						// Amount reported is negative if other account hold's current account's IOUs.
-						jPeer["balance"]	= saBalance.getText();
-						jPeer["currency"]	= saBalance.getHumanCurrency();
-						jPeer["limit"]		= saLimit.getText();
-						jPeer["limit_peer"]	= saLimitPeer.getText();
-
-						jsonLines.append(jPeer);
-					}
-					else
-					{
-						Log(lsWARNING) << "doRippleLinesGet: Bad index: " << uNode.ToString();
-					}
-				}
-
-				if (uNodeNext)
-				{
-					uCurrent	= Ledger::getDirNodeIndex(uRootIndex, uNodeNext);
-				}
-				else
-				{
-					bDone	= true;
-				}
-			}
-		}
-		else
-		{
-			Log(lsINFO) << "doRippleLinesGet: no directory: " << uRootIndex.ToString();
+			jsonLines.append(jPeer);
 		}
 		ret["lines"]	= jsonLines;
 	}

src/RippleLines.cpp

@@ -0,0 +1,48 @@
+#include "RippleLines.h"
+#include "Application.h"
+#include "Log.h"
+#include <boost/foreach.hpp>
+
+RippleLines::RippleLines(const uint160& accountID, Ledger::pointer ledger)
+{
+	fillLines(accountID,ledger);
+}
+
+RippleLines::RippleLines(const uint160& accountID )
+{
+	fillLines(accountID,theApp->getMasterLedger().getCurrentLedger());
+}
+
+void RippleLines::fillLines(const uint160& accountID, Ledger::pointer ledger)
+{
+	uint256 rootIndex	= Ledger::getRippleDirIndex(accountID);
+	uint256 currentIndex=rootIndex;
+
+	LedgerStateParms	lspNode		= lepNONE;
+
+	while(1)
+	{
+		SerializedLedgerEntry::pointer rippleDir=ledger->getDirNode(lspNode,currentIndex);
+		if(!rippleDir) return;
+
+		STVector256 svRippleNodes		= rippleDir->getIFieldV256(sfIndexes);
+		BOOST_FOREACH(uint256& uNode, svRippleNodes.peekValue())
+		{
+			RippleState::pointer	rsLine	= ledger->accessRippleState(uNode);
+			if (rsLine)
+			{
+				rsLine->setViewAccount(accountID);
+				mLines.push_back(rsLine);
+			}
+			else
+			{
+				Log(lsWARNING) << "doRippleLinesGet: Bad index: " << uNode.ToString();
+			}
+		}
+
+		uint64 uNodeNext		= rippleDir->getIFieldU64(sfIndexNext);
+		if(!uNodeNext) return;
+
+		currentIndex	= Ledger::getDirNodeIndex(rootIndex, uNodeNext);
+	}
+}

src/RippleLines.h

@@ -0,0 +1,19 @@
+#include "Ledger.h"
+#include "RippleState.h"
+
+/*
+This pulls all the ripple lines of a given account out of the ledger.
+It provides a vector so you to easily iterate through them
+*/
+
+class RippleLines
+{
+	std::vector<RippleState::pointer> mLines;
+	void fillLines(const uint160& accountID, Ledger::pointer ledger);
+public:
+
+	RippleLines(const uint160& accountID, Ledger::pointer ledger);
+	RippleLines(const uint160& accountID ); // looks in the current ledger
+
+	std::vector<RippleState::pointer>& getLines(){ return(mLines); }
+};

src/RippleState.cpp

@@ -18,9 +18,9 @@ RippleState::RippleState(SerializedLedgerEntry::pointer ledgerEntry) :
 	mValid		= true;
 }
 
-void RippleState::setViewAccount(const NewcoinAddress& naView)
+void RippleState::setViewAccount(const uint160& accountID)
 {
-	bool	bViewLowestNew	= mLowID.getAccountID() == naView.getAccountID();
+	bool	bViewLowestNew	= mLowID.getAccountID() == accountID;
 
 	if (bViewLowestNew != mViewLowest)
 	{

src/RippleState.h

@@ -32,7 +32,7 @@ private:
 public:
 	RippleState(SerializedLedgerEntry::pointer ledgerEntry);	// For accounts in a ledger
 
-	void					setViewAccount(const NewcoinAddress& naView);
+	void					setViewAccount(const uint160& accountID);
 
 	const NewcoinAddress	getAccountID() const		{ return mViewLowest ? mLowID : mHighID; }
 	const NewcoinAddress	getAccountIDPeer() const	{ return mViewLowest ? mHighID : mLowID; }

src/ValidationCollection.cpp

@@ -7,7 +7,7 @@
 
 // #define VC_DEBUG
 
-bool ValidationCollection::addValidation(SerializedValidation::pointer& val)
+bool ValidationCollection::addValidation(const SerializedValidation::pointer& val)
 {
 	NewcoinAddress signer = val->getSignerPublic();
 	bool isCurrent = false;

src/ValidationCollection.h

@@ -17,7 +17,7 @@ class ValidationPair
 public:
 	SerializedValidation::pointer oldest, newest;
 
-	ValidationPair(SerializedValidation::pointer v) : newest(v) { ; }
+	ValidationPair(const SerializedValidation::pointer& v) : newest(v) { ; }
 };
 
 class ValidationCollection
@@ -38,7 +38,7 @@ protected:
 public:
 	ValidationCollection() : mWriting(false) { ; }
 
-	bool addValidation(SerializedValidation::pointer&);
+	bool addValidation(const SerializedValidation::pointer&);
 	ValidationSet getValidations(const uint256& ledger);
 	void getValidationCount(const uint256& ledger, bool currentOnly, int& trusted, int& untrusted);