diff --git a/src/LedgerAcquire.cpp b/src/LedgerAcquire.cpp
index 95cf414156..f5579a9c30 100644
--- a/src/LedgerAcquire.cpp
+++ b/src/LedgerAcquire.cpp
@@ -194,9 +194,9 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
 #endif
 	if (!mHaveBase)
 	{
-		newcoin::TMGetLedger tmGL;
+		ripple::TMGetLedger tmGL;
 		tmGL.set_ledgerhash(mHash.begin(), mHash.size());
-		tmGL.set_itype(newcoin::liBASE);
+		tmGL.set_itype(ripple::liBASE);
 		*(tmGL.add_nodeids()) = SHAMapNode().getRawString();
 		sendRequest(tmGL, peer);
 	}
@@ -209,10 +209,10 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
 		assert(mLedger);
 		if (mLedger->peekTransactionMap()->getHash().isZero())
 		{ // we need the root node
-			newcoin::TMGetLedger tmGL;
+			ripple::TMGetLedger tmGL;
 			tmGL.set_ledgerhash(mHash.begin(), mHash.size());
 			tmGL.set_ledgerseq(mLedger->getLedgerSeq());
-			tmGL.set_itype(newcoin::liTX_NODE);
+			tmGL.set_itype(ripple::liTX_NODE);
 			*(tmGL.add_nodeids()) = SHAMapNode().getRawString();
 			sendRequest(tmGL, peer);
 		}
@@ -234,10 +234,10 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
 			}
 			else
 			{
-				newcoin::TMGetLedger tmGL;
+				ripple::TMGetLedger tmGL;
 				tmGL.set_ledgerhash(mHash.begin(), mHash.size());
 				tmGL.set_ledgerseq(mLedger->getLedgerSeq());
-				tmGL.set_itype(newcoin::liTX_NODE);
+				tmGL.set_itype(ripple::liTX_NODE);
 				for (std::vector<SHAMapNode>::iterator it = nodeIDs.begin(); it != nodeIDs.end(); ++it)
 					*(tmGL.add_nodeids()) = it->getRawString();
 				sendRequest(tmGL, peer);
@@ -253,10 +253,10 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
 		assert(mLedger);
 		if (mLedger->peekAccountStateMap()->getHash().isZero())
 		{ // we need the root node
-			newcoin::TMGetLedger tmGL;
+			ripple::TMGetLedger tmGL;
 			tmGL.set_ledgerhash(mHash.begin(), mHash.size());
 			tmGL.set_ledgerseq(mLedger->getLedgerSeq());
-			tmGL.set_itype(newcoin::liAS_NODE);
+			tmGL.set_itype(ripple::liAS_NODE);
 			*(tmGL.add_nodeids()) = SHAMapNode().getRawString();
 			sendRequest(tmGL, peer);
 		}
@@ -278,10 +278,10 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
 			}
 			else
 			{
-				newcoin::TMGetLedger tmGL;
+				ripple::TMGetLedger tmGL;
 				tmGL.set_ledgerhash(mHash.begin(), mHash.size());
 				tmGL.set_ledgerseq(mLedger->getLedgerSeq());
-				tmGL.set_itype(newcoin::liAS_NODE);
+				tmGL.set_itype(ripple::liAS_NODE);
 				for (std::vector<SHAMapNode>::iterator it = nodeIDs.begin(); it != nodeIDs.end(); ++it)
 					*(tmGL.add_nodeids()) = it->getRawString();
 				sendRequest(tmGL, peer);
@@ -295,21 +295,21 @@ void LedgerAcquire::trigger(Peer::ref peer, bool timer)
 		resetTimer();
 }
 
-void PeerSet::sendRequest(const newcoin::TMGetLedger& tmGL, Peer::ref peer)
+void PeerSet::sendRequest(const ripple::TMGetLedger& tmGL, Peer::ref peer)
 {
 	if (!peer)
 		sendRequest(tmGL);
 	else
-		peer->sendPacket(boost::make_shared<PackedMessage>(tmGL, newcoin::mtGET_LEDGER));
+		peer->sendPacket(boost::make_shared<PackedMessage>(tmGL, ripple::mtGET_LEDGER));
 }
 
-void PeerSet::sendRequest(const newcoin::TMGetLedger& tmGL)
+void PeerSet::sendRequest(const ripple::TMGetLedger& tmGL)
 {
 	boost::recursive_mutex::scoped_lock sl(mLock);
 	if (mPeers.empty())
 		return;
 
-	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tmGL, newcoin::mtGET_LEDGER);
+	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tmGL, ripple::mtGET_LEDGER);
 
 	std::vector< boost::weak_ptr<Peer> >::iterator it = mPeers.begin();
 	while (it != mPeers.end())
@@ -476,7 +476,7 @@ void LedgerAcquireMaster::dropLedger(const uint256& hash)
 	mLedgers.erase(hash);
 }
 
-bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref peer)
+bool LedgerAcquireMaster::gotLedgerData(ripple::TMLedgerData& packet, Peer::ref peer)
 {
 #ifdef LA_DEBUG
 	Log(lsTRACE) << "got data for acquiring ledger ";
@@ -495,11 +495,11 @@ bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref
 	LedgerAcquire::pointer ledger = find(hash);
 	if (!ledger) return false;
 
-	if (packet.type() == newcoin::liBASE)
+	if (packet.type() == ripple::liBASE)
 	{
 		if (packet.nodes_size() < 1)
 			return false;
-		const newcoin::TMLedgerNode& node = packet.nodes(0);
+		const ripple::TMLedgerNode& node = packet.nodes(0);
 		if (!ledger->takeBase(node.nodedata()))
 			return false;
 		if (packet.nodes_size() == 1)
@@ -522,7 +522,7 @@ bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref
 		return true;
 	}
 
-	if ((packet.type() == newcoin::liTX_NODE) || (packet.type() == newcoin::liAS_NODE))
+	if ((packet.type() == ripple::liTX_NODE) || (packet.type() == ripple::liAS_NODE))
 	{
 		std::list<SHAMapNode> nodeIDs;
 		std::list< std::vector<unsigned char> > nodeData;
@@ -530,14 +530,14 @@ bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref
 		if (packet.nodes().size() <= 0) return false;
 		for (int i = 0; i < packet.nodes().size(); ++i)
 		{
-			const newcoin::TMLedgerNode& node = packet.nodes(i);
+			const ripple::TMLedgerNode& node = packet.nodes(i);
 			if (!node.has_nodeid() || !node.has_nodedata()) return false;
 
 			nodeIDs.push_back(SHAMapNode(node.nodeid().data(), node.nodeid().size()));
 			nodeData.push_back(std::vector<unsigned char>(node.nodedata().begin(), node.nodedata().end()));
 		}
 		bool ret;
-		if (packet.type() == newcoin::liTX_NODE)
+		if (packet.type() == ripple::liTX_NODE)
 			ret = ledger->takeTxNode(nodeIDs, nodeData);
 		else
 			ret = ledger->takeAsNode(nodeIDs, nodeData);
diff --git a/src/LedgerAcquire.h b/src/LedgerAcquire.h
index 82541733f9..196a325c11 100644
--- a/src/LedgerAcquire.h
+++ b/src/LedgerAcquire.h
@@ -30,8 +30,8 @@ protected:
 	PeerSet(const uint256& hash, int interval);
 	virtual ~PeerSet() { ; }
 
-	void sendRequest(const newcoin::TMGetLedger& message);
-	void sendRequest(const newcoin::TMGetLedger& message, Peer::ref peer);
+	void sendRequest(const ripple::TMGetLedger& message);
+	void sendRequest(const ripple::TMGetLedger& message, Peer::ref peer);
 
 public:
 	const uint256& getHash() const		{ return mHash; }
@@ -110,7 +110,7 @@ public:
 	LedgerAcquire::pointer find(const uint256& hash);
 	bool hasLedger(const uint256& ledgerHash);
 	void dropLedger(const uint256& ledgerHash);
-	bool gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref);
+	bool gotLedgerData(ripple::TMLedgerData& packet, Peer::ref);
 };
 
 #endif
diff --git a/src/LedgerConsensus.cpp b/src/LedgerConsensus.cpp
index c915faad7d..624e8febf7 100644
--- a/src/LedgerConsensus.cpp
+++ b/src/LedgerConsensus.cpp
@@ -59,9 +59,9 @@ void TransactionAcquire::trigger(Peer::ref peer, bool timer)
 	if (!mHaveRoot)
 	{
 		cLog(lsINFO) << "have no root";
-		newcoin::TMGetLedger tmGL;
+		ripple::TMGetLedger tmGL;
 		tmGL.set_ledgerhash(mHash.begin(), mHash.size());
-		tmGL.set_itype(newcoin::liTS_CANDIDATE);
+		tmGL.set_itype(ripple::liTS_CANDIDATE);
 		*(tmGL.add_nodeids()) = SHAMapNode().getRawString();
 		sendRequest(tmGL, peer);
 	}
@@ -82,9 +82,9 @@ void TransactionAcquire::trigger(Peer::ref peer, bool timer)
 		}
 		else
 		{
-			newcoin::TMGetLedger tmGL;
+			ripple::TMGetLedger tmGL;
 			tmGL.set_ledgerhash(mHash.begin(), mHash.size());
-			tmGL.set_itype(newcoin::liTS_CANDIDATE);
+			tmGL.set_itype(ripple::liTS_CANDIDATE);
 			for (std::vector<SHAMapNode>::iterator it = nodeIDs.begin(); it != nodeIDs.end(); ++it)
 				*(tmGL.add_nodeids()) = it->getRawString();
 			sendRequest(tmGL, peer);
@@ -464,10 +464,10 @@ void LedgerConsensus::mapComplete(const uint256& hash, SHAMap::ref map, bool acq
 
 void LedgerConsensus::sendHaveTxSet(const uint256& hash, bool direct)
 {
-	newcoin::TMHaveTransactionSet msg;
+	ripple::TMHaveTransactionSet msg;
 	msg.set_hash(hash.begin(), 256 / 8);
-	msg.set_status(direct ? newcoin::tsHAVE : newcoin::tsCAN_GET);
-	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(msg, newcoin::mtHAVE_SET);
+	msg.set_status(direct ? ripple::tsHAVE : ripple::tsCAN_GET);
+	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(msg, ripple::mtHAVE_SET);
 	theApp->getConnectionPool().relayMessage(NULL, packet);
 }
 
@@ -481,11 +481,11 @@ void LedgerConsensus::adjustCount(SHAMap::ref map, const std::vector<uint160>& p
 	}
 }
 
-void LedgerConsensus::statusChange(newcoin::NodeEvent event, Ledger& ledger)
+void LedgerConsensus::statusChange(ripple::NodeEvent event, Ledger& ledger)
 { // Send a node status change message to our peers
-	newcoin::TMStatusChange s;
+	ripple::TMStatusChange s;
 	if (!mHaveCorrectLCL)
-		s.set_newevent(newcoin::neLOST_SYNC);
+		s.set_newevent(ripple::neLOST_SYNC);
 	else
 		s.set_newevent(event);
 	s.set_ledgerseq(ledger.getLedgerSeq());
@@ -494,7 +494,7 @@ void LedgerConsensus::statusChange(newcoin::NodeEvent event, Ledger& ledger)
 	s.set_ledgerhashprevious(hash.begin(), hash.size());
 	hash = ledger.getHash();
 	s.set_ledgerhash(hash.begin(), hash.size());
-	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, newcoin::mtSTATUS_CHANGE);
+	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, ripple::mtSTATUS_CHANGE);
 	theApp->getConnectionPool().relayMessage(NULL, packet);
 	cLog(lsINFO) << "send status change to peer";
 }
@@ -539,7 +539,7 @@ void LedgerConsensus::closeLedger()
 		mConsensusStartTime = boost::posix_time::microsec_clock::universal_time();
 		mCloseTime = theApp->getOPs().getCloseTimeNC();
 		theApp->getOPs().setLastCloseTime(mCloseTime);
-		statusChange(newcoin::neCLOSING_LEDGER, *mPreviousLedger);
+		statusChange(ripple::neCLOSING_LEDGER, *mPreviousLedger);
 		takeInitialPosition(*theApp->getMasterLedger().closeLedger());
 }
 
@@ -807,7 +807,7 @@ void LedgerConsensus::startAcquiring(const TransactionAcquire::pointer& acquire)
 void LedgerConsensus::propose()
 {
 	cLog(lsTRACE) << "We propose: " << mOurPosition->getCurrentHash();
-	newcoin::TMProposeSet prop;
+	ripple::TMProposeSet prop;
 	prop.set_currenttxhash(mOurPosition->getCurrentHash().begin(), 256 / 8);
 	prop.set_proposeseq(mOurPosition->getProposeSeq());
 	prop.set_closetime(mOurPosition->getCloseTime());
@@ -817,7 +817,7 @@ void LedgerConsensus::propose()
 	prop.set_nodepubkey(&pubKey[0], pubKey.size());
 	prop.set_signature(&sig[0], sig.size());
 	theApp->getConnectionPool().relayMessage(NULL,
-		boost::make_shared<PackedMessage>(prop, newcoin::mtPROPOSE_LEDGER));
+		boost::make_shared<PackedMessage>(prop, ripple::mtPROPOSE_LEDGER));
 }
 
 void LedgerConsensus::addDisputedTransaction(const uint256& txID, const std::vector<unsigned char>& tx)
@@ -850,11 +850,11 @@ void LedgerConsensus::addDisputedTransaction(const uint256& txID, const std::vec
 
 	if (!ourVote && theApp->isNew(txID))
 	{
-		newcoin::TMTransaction msg;
+		ripple::TMTransaction msg;
 		msg.set_rawtransaction(&(tx.front()), tx.size());
-		msg.set_status(newcoin::tsNEW);
+		msg.set_status(ripple::tsNEW);
 		msg.set_receivetimestamp(theApp->getOPs().getNetworkTimeNC());
-		PackedMessage::pointer packet = boost::make_shared<PackedMessage>(msg, newcoin::mtTRANSACTION);
+		PackedMessage::pointer packet = boost::make_shared<PackedMessage>(msg, ripple::mtTRANSACTION);
         theApp->getConnectionPool().relayMessage(NULL, packet);
 	}
 }
@@ -907,9 +907,9 @@ bool LedgerConsensus::peerPosition(const LedgerProposal::pointer& newPosition)
 	return true;
 }
 
-bool LedgerConsensus::peerHasSet(Peer::ref peer, const uint256& hashSet, newcoin::TxSetStatus status)
+bool LedgerConsensus::peerHasSet(Peer::ref peer, const uint256& hashSet, ripple::TxSetStatus status)
 {
-	if (status != newcoin::tsHAVE) // Indirect requests are for future support
+	if (status != ripple::tsHAVE) // Indirect requests are for future support
 		return true;
 
 	std::vector< boost::weak_ptr<Peer> >& set = mPeerData[hashSet];
@@ -1114,7 +1114,7 @@ void LedgerConsensus::accept(SHAMap::ref set)
 	newLCL->setAccepted(closeTime, mCloseResolution, closeTimeCorrect);
 	newLCL->updateHash();
 	uint256 newLCLHash = newLCL->getHash();
-	statusChange(newcoin::neACCEPTED_LEDGER, *newLCL);
+	statusChange(ripple::neACCEPTED_LEDGER, *newLCL);
 	if (mValidating)
 	{
 		SerializedValidation::pointer v = boost::make_shared<SerializedValidation>
@@ -1122,10 +1122,10 @@ void LedgerConsensus::accept(SHAMap::ref set)
 		v->setTrusted();
 		theApp->getValidations().addValidation(v);
 		std::vector<unsigned char> validation = v->getSigned();
-		newcoin::TMValidation val;
+		ripple::TMValidation val;
 		val.set_validation(&validation[0], validation.size());
 		int j = theApp->getConnectionPool().relayMessage(NULL,
-			boost::make_shared<PackedMessage>(val, newcoin::mtVALIDATION));
+			boost::make_shared<PackedMessage>(val, ripple::mtVALIDATION));
 		cLog(lsINFO) << "CNF Val " << newLCLHash << " to " << j << " peers";
 	}
 	else
diff --git a/src/LedgerConsensus.h b/src/LedgerConsensus.h
index 6e5d81a552..ffe8db5d3c 100644
--- a/src/LedgerConsensus.h
+++ b/src/LedgerConsensus.h
@@ -143,7 +143,7 @@ protected:
 	uint32 roundCloseTime(uint32 closeTime);
 
 	// manipulating our own position
-	void statusChange(newcoin::NodeEvent, Ledger& ledger);
+	void statusChange(ripple::NodeEvent, Ledger& ledger);
 	void takeInitialPosition(Ledger& initialLedger);
 	void updateOurPositions();
 	void playbackProposals();
@@ -182,7 +182,7 @@ public:
 	bool peerPosition(const LedgerProposal::pointer&);
 	void deferProposal(const LedgerProposal::pointer& proposal,	const NewcoinAddress& peerPublic);
 
-	bool peerHasSet(Peer::ref peer, const uint256& set, newcoin::TxSetStatus status);
+	bool peerHasSet(Peer::ref peer, const uint256& set, ripple::TxSetStatus status);
 
 	bool peerGaveNodes(Peer::ref peer, const uint256& setHash,
 		const std::list<SHAMapNode>& nodeIDs, const std::list< std::vector<unsigned char> >& nodeData);
diff --git a/src/NetworkOPs.cpp b/src/NetworkOPs.cpp
index 6a01d4268f..b02bef0c1d 100644
--- a/src/NetworkOPs.cpp
+++ b/src/NetworkOPs.cpp
@@ -154,14 +154,14 @@ Transaction::pointer NetworkOPs::processTransaction(Transaction::pointer trans,
 // no cache the account balance information and always get it from the current ledger
 //		theApp->getWallet().applyTransaction(trans);
 
-		newcoin::TMTransaction tx;
+		ripple::TMTransaction tx;
 		Serializer s;
 		trans->getSTransaction()->add(s);
 		tx.set_rawtransaction(&s.getData().front(), s.getLength());
-		tx.set_status(newcoin::tsCURRENT);
+		tx.set_status(ripple::tsCURRENT);
 		tx.set_receivetimestamp(getNetworkTimeNC());
 
-		PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tx, newcoin::mtTRANSACTION);
+		PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tx, ripple::mtTRANSACTION);
 		int sentTo = theApp->getConnectionPool().relayMessage(source, packet);
 		cLog(lsINFO) << "Transaction relayed to " << sentTo << " node(s)";
 
@@ -171,13 +171,13 @@ Transaction::pointer NetworkOPs::processTransaction(Transaction::pointer trans,
 	cLog(lsDEBUG) << "Status other than success " << r;
 	if ((mMode != omFULL) && (mMode != omTRACKING) && (theApp->isNew(trans->getID())))
 	{
-		newcoin::TMTransaction tx;
+		ripple::TMTransaction tx;
 		Serializer s;
 		trans->getSTransaction()->add(s);
 		tx.set_rawtransaction(&s.getData().front(), s.getLength());
-		tx.set_status(newcoin::tsCURRENT);
+		tx.set_status(ripple::tsCURRENT);
 		tx.set_receivetimestamp(getNetworkTimeNC());
-		PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tx, newcoin::mtTRANSACTION);
+		PackedMessage::pointer packet = boost::make_shared<PackedMessage>(tx, ripple::mtTRANSACTION);
 		theApp->getConnectionPool().relayMessage(source, packet);
 	}
 
@@ -624,15 +624,15 @@ void NetworkOPs::switchLastClosedLedger(Ledger::pointer newLedger, bool duringCo
 	Ledger::pointer openLedger = boost::make_shared<Ledger>(false, boost::ref(*newLedger));
 	mLedgerMaster->switchLedgers(newLedger, openLedger);
 
-	newcoin::TMStatusChange s;
-	s.set_newevent(newcoin::neSWITCHED_LEDGER);
+	ripple::TMStatusChange s;
+	s.set_newevent(ripple::neSWITCHED_LEDGER);
 	s.set_ledgerseq(newLedger->getLedgerSeq());
 	s.set_networktime(theApp->getOPs().getNetworkTimeNC());
 	uint256 hash = newLedger->getParentHash();
 	s.set_ledgerhashprevious(hash.begin(), hash.size());
 	hash = newLedger->getHash();
 	s.set_ledgerhash(hash.begin(), hash.size());
-	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, newcoin::mtSTATUS_CHANGE);
+	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(s, ripple::mtSTATUS_CHANGE);
 	theApp->getConnectionPool().relayMessage(NULL, packet);
 }
 
@@ -757,7 +757,7 @@ bool NetworkOPs::gotTXData(const boost::shared_ptr<Peer>& peer, const uint256& h
 	return mConsensus->peerGaveNodes(peer, hash, nodeIDs, nodeData);
 }
 
-bool NetworkOPs::hasTXSet(const boost::shared_ptr<Peer>& peer, const uint256& set, newcoin::TxSetStatus status)
+bool NetworkOPs::hasTXSet(const boost::shared_ptr<Peer>& peer, const uint256& set, ripple::TxSetStatus status)
 {
 	if (!haveConsensusObject())
 	{
diff --git a/src/NetworkOPs.h b/src/NetworkOPs.h
index 043ae313b7..ea4180d8d3 100644
--- a/src/NetworkOPs.h
+++ b/src/NetworkOPs.h
@@ -173,7 +173,7 @@ public:
 		const std::list<SHAMapNode>& nodeIDs, const std::list< std::vector<unsigned char> >& nodeData);
 	bool recvValidation(const SerializedValidation::pointer& val);
 	SHAMap::pointer getTXMap(const uint256& hash);
-	bool hasTXSet(const boost::shared_ptr<Peer>& peer, const uint256& set, newcoin::TxSetStatus status);
+	bool hasTXSet(const boost::shared_ptr<Peer>& peer, const uint256& set, ripple::TxSetStatus status);
 	void mapComplete(const uint256& hash, SHAMap::ref map);
 
 	// network state machine
diff --git a/src/Peer.cpp b/src/Peer.cpp
index 5e6875c807..8fdeea74ba 100644
--- a/src/Peer.cpp
+++ b/src/Peer.cpp
@@ -370,7 +370,7 @@ void Peer::processReadBuffer()
 //	std::cerr << "Peer::processReadBuffer: " << mIpPort.first << " " << mIpPort.second << std::endl;
 
 	// If connected and get a mtHELLO or if not connected and get a non-mtHELLO, wrong message was sent.
-	if (mHelloed == (type == newcoin::mtHELLO))
+	if (mHelloed == (type == ripple::mtHELLO))
 	{
 		cLog(lsWARNING) << "Wrong message type: " << type;
 		detach("prb1");
@@ -379,160 +379,160 @@ void Peer::processReadBuffer()
 	{
 		switch(type)
 		{
-		case newcoin::mtHELLO:
+		case ripple::mtHELLO:
 			{
-				newcoin::TMHello msg;
+				ripple::TMHello msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvHello(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtERROR_MSG:
+		case ripple::mtERROR_MSG:
 			{
-				newcoin::TMErrorMsg msg;
+				ripple::TMErrorMsg msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvErrorMessage(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtPING:
+		case ripple::mtPING:
 			{
-				newcoin::TMPing msg;
+				ripple::TMPing msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvPing(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtGET_CONTACTS:
+		case ripple::mtGET_CONTACTS:
 			{
-				newcoin::TMGetContacts msg;
+				ripple::TMGetContacts msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvGetContacts(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtCONTACT:
+		case ripple::mtCONTACT:
 			{
-				newcoin::TMContact msg;
+				ripple::TMContact msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvContact(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
-		case newcoin::mtGET_PEERS:
+		case ripple::mtGET_PEERS:
 			{
-				newcoin::TMGetPeers msg;
+				ripple::TMGetPeers msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvGetPeers(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
-		case newcoin::mtPEERS:
+		case ripple::mtPEERS:
 			{
-				newcoin::TMPeers msg;
+				ripple::TMPeers msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvPeers(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtSEARCH_TRANSACTION:
+		case ripple::mtSEARCH_TRANSACTION:
 			{
-				newcoin::TMSearchTransaction msg;
+				ripple::TMSearchTransaction msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvSearchTransaction(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtGET_ACCOUNT:
+		case ripple::mtGET_ACCOUNT:
 			{
-				newcoin::TMGetAccount msg;
+				ripple::TMGetAccount msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvGetAccount(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtACCOUNT:
+		case ripple::mtACCOUNT:
 			{
-				newcoin::TMAccount msg;
+				ripple::TMAccount msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvAccount(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtTRANSACTION:
+		case ripple::mtTRANSACTION:
 			{
-				newcoin::TMTransaction msg;
+				ripple::TMTransaction msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvTransaction(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtSTATUS_CHANGE:
+		case ripple::mtSTATUS_CHANGE:
 			{
-				newcoin::TMStatusChange msg;
+				ripple::TMStatusChange msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvStatus(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtPROPOSE_LEDGER:
+		case ripple::mtPROPOSE_LEDGER:
 			{
-				newcoin::TMProposeSet msg;
+				ripple::TMProposeSet msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvPropose(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtGET_LEDGER:
+		case ripple::mtGET_LEDGER:
 			{
-				newcoin::TMGetLedger msg;
+				ripple::TMGetLedger msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvGetLedger(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtLEDGER_DATA:
+		case ripple::mtLEDGER_DATA:
 			{
-				newcoin::TMLedgerData msg;
+				ripple::TMLedgerData msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvLedger(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtHAVE_SET:
+		case ripple::mtHAVE_SET:
 			{
-				newcoin::TMHaveTransactionSet msg;
+				ripple::TMHaveTransactionSet msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvHaveTxSet(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 
-		case newcoin::mtVALIDATION:
+		case ripple::mtVALIDATION:
 			{
-				newcoin::TMValidation msg;
+				ripple::TMValidation msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvValidation(msg);
 				else std::cerr << "parse error: " << type << std::endl;
 			}
 			break;
 #if 0
-		case newcoin::mtGET_VALIDATION:
+		case ripple::mtGET_VALIDATION:
 			{
-				newcoin::TM msg;
+				ripple::TM msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recv(msg);
 				else std::cerr << "parse error: " << type << std::endl;
@@ -540,9 +540,9 @@ void Peer::processReadBuffer()
 			break;
 
 #endif
-		case newcoin::mtGET_OBJECTS:
+		case ripple::mtGET_OBJECTS:
 			{
-				newcoin::TMGetObjectByHash msg;
+				ripple::TMGetObjectByHash msg;
 				if (msg.ParseFromArray(&mReadbuf[HEADER_SIZE], mReadbuf.size() - HEADER_SIZE))
 					recvGetObjectByHash(msg);
 				else std::cerr << "parse error: " << type << std::endl;
@@ -556,7 +556,7 @@ void Peer::processReadBuffer()
 	}
 }
 
-void Peer::recvHello(newcoin::TMHello& packet)
+void Peer::recvHello(ripple::TMHello& packet)
 {
 	bool	bDetach	= true;
 
@@ -667,7 +667,7 @@ void Peer::recvHello(newcoin::TMHello& packet)
 	}
 }
 
-void Peer::recvTransaction(newcoin::TMTransaction& packet)
+void Peer::recvTransaction(ripple::TMTransaction& packet)
 {
 #ifdef DEBUG
 	std::cerr << "Got transaction from peer" << std::endl;
@@ -708,7 +708,7 @@ void Peer::recvTransaction(newcoin::TMTransaction& packet)
 	}
 }
 
-void Peer::recvPropose(newcoin::TMProposeSet& packet)
+void Peer::recvPropose(ripple::TMProposeSet& packet)
 {
 	if ((packet.currenttxhash().size() != 32) || (packet.nodepubkey().size() < 28) ||
 		(packet.signature().size() < 56))
@@ -726,12 +726,12 @@ void Peer::recvPropose(newcoin::TMProposeSet& packet)
 	if(theApp->getOPs().recvPropose(packet.proposeseq(), currentTxHash, prevLedger, packet.closetime(),
 		packet.nodepubkey(), packet.signature(), mNodePublic))
 	{ // FIXME: Not all nodes will want proposals 
-		PackedMessage::pointer message = boost::make_shared<PackedMessage>(packet, newcoin::mtPROPOSE_LEDGER);
+		PackedMessage::pointer message = boost::make_shared<PackedMessage>(packet, ripple::mtPROPOSE_LEDGER);
 		theApp->getConnectionPool().relayMessage(this, message);
 	}
 }
 
-void Peer::recvHaveTxSet(newcoin::TMHaveTransactionSet& packet)
+void Peer::recvHaveTxSet(ripple::TMHaveTransactionSet& packet)
 {
 	// FIXME: We should have some limit on the number of HaveTxSet messages a peer can send us
 	// per consensus pass, to keep a peer from running up our memory without limit
@@ -743,13 +743,13 @@ void Peer::recvHaveTxSet(newcoin::TMHaveTransactionSet& packet)
 	}
 	uint256 hash;
 	memcpy(hash.begin(), packet.hash().data(), 32);
-	if (packet.status() == newcoin::tsHAVE)
+	if (packet.status() == ripple::tsHAVE)
 		addTxSet(hash);
 	if (!theApp->getOPs().hasTXSet(shared_from_this(), hash, packet.status()))
 		punishPeer(PP_UNWANTED_DATA);
 }
 
-void Peer::recvValidation(newcoin::TMValidation& packet)
+void Peer::recvValidation(ripple::TMValidation& packet)
 {
 	if (packet.validation().size() < 50)
 	{
@@ -784,7 +784,7 @@ void Peer::recvValidation(newcoin::TMValidation& packet)
 
 		if (theApp->getOPs().recvValidation(val))
 		{
-			PackedMessage::pointer message = boost::make_shared<PackedMessage>(packet, newcoin::mtVALIDATION);
+			PackedMessage::pointer message = boost::make_shared<PackedMessage>(packet, ripple::mtVALIDATION);
 			theApp->getConnectionPool().relayMessage(this, message);
 		}
 	}
@@ -797,22 +797,22 @@ void Peer::recvValidation(newcoin::TMValidation& packet)
 //#endif
 }
 
-void Peer::recvGetValidation(newcoin::TMGetValidations& packet)
+void Peer::recvGetValidation(ripple::TMGetValidations& packet)
 {
 }
 
-void Peer::recvContact(newcoin::TMContact& packet)
+void Peer::recvContact(ripple::TMContact& packet)
 {
 }
 
-void Peer::recvGetContacts(newcoin::TMGetContacts& packet)
+void Peer::recvGetContacts(ripple::TMGetContacts& packet)
 {
 }
 
 // return a list of your favorite people
 // TODO: filter out all the LAN peers
 // TODO: filter out the peer you are talking to
-void Peer::recvGetPeers(newcoin::TMGetPeers& packet)
+void Peer::recvGetPeers(ripple::TMGetPeers& packet)
 {
 	std::vector<std::string> addrs;
 
@@ -820,7 +820,7 @@ void Peer::recvGetPeers(newcoin::TMGetPeers& packet)
 
 	if (!addrs.empty())
 	{
-		newcoin::TMPeers peers;
+		ripple::TMPeers peers;
 
 		for (unsigned int n=0; n<addrs.size(); n++)
 		{
@@ -830,20 +830,20 @@ void Peer::recvGetPeers(newcoin::TMGetPeers& packet)
 			splitIpPort(addrs[n], strIP, iPort);
 
 			// XXX This should also ipv6
-			newcoin::TMIPv4EndPoint* addr=peers.add_nodes();
+			ripple::TMIPv4EndPoint* addr=peers.add_nodes();
 			addr->set_ipv4(inet_addr(strIP.c_str()));
 			addr->set_ipv4port(iPort);
 
 			//cLog(lsINFO) << "Peer: Teaching: " << ADDRESS(this) << ": " << n << ": " << strIP << " " << iPort;
 		}
 
-		PackedMessage::pointer message = boost::make_shared<PackedMessage>(peers, newcoin::mtPEERS);
+		PackedMessage::pointer message = boost::make_shared<PackedMessage>(peers, ripple::mtPEERS);
 		sendPacket(message);
 	}
 }
 
 // TODO: filter out all the LAN peers
-void Peer::recvPeers(newcoin::TMPeers& packet)
+void Peer::recvPeers(ripple::TMPeers& packet)
 {
 	for (int i = 0; i < packet.nodes().size(); ++i)
 	{
@@ -863,11 +863,11 @@ void Peer::recvPeers(newcoin::TMPeers& packet)
 	}
 }
 
-void Peer::recvGetObjectByHash(newcoin::TMGetObjectByHash& packet)
+void Peer::recvGetObjectByHash(ripple::TMGetObjectByHash& packet)
 {
 	if (packet.query())
 	{ // this is a query
-		newcoin::TMGetObjectByHash reply;
+		ripple::TMGetObjectByHash reply;
 
 		reply.clear_query();
 		if (packet.has_seq())
@@ -880,14 +880,14 @@ void Peer::recvGetObjectByHash(newcoin::TMGetObjectByHash& packet)
 		for (unsigned i = 0; i < packet.objects_size(); ++i)
 		{
 			uint256 hash;
-			const newcoin::TMIndexedObject& obj = packet.objects(i);
+			const ripple::TMIndexedObject& obj = packet.objects(i);
 			if (obj.has_hash() && (obj.hash().size() == (256/8)))
 			{
 				memcpy(hash.begin(), obj.hash().data(), 256 / 8);
 				HashedObject::pointer hObj = theApp->getHashedObjectStore().retrieve(hash);
 				if (hObj)
 				{
-					newcoin::TMIndexedObject& newObj = *reply.add_objects();
+					ripple::TMIndexedObject& newObj = *reply.add_objects();
 					newObj.set_hash(hash.begin(), hash.size());
 					newObj.set_data(&hObj->getData().front(), hObj->getData().size());
 					if (obj.has_nodeid())
@@ -896,7 +896,7 @@ void Peer::recvGetObjectByHash(newcoin::TMGetObjectByHash& packet)
 			}
 		}
 		cLog(lsDEBUG) << "GetObjByHash query: had " << reply.objects_size() << " of " << packet.objects_size();
-		sendPacket(boost::make_shared<PackedMessage>(packet, newcoin::mtGET_OBJECTS));
+		sendPacket(boost::make_shared<PackedMessage>(packet, ripple::mtGET_OBJECTS));
 	}
 	else
 	{ // this is a reply
@@ -904,27 +904,27 @@ void Peer::recvGetObjectByHash(newcoin::TMGetObjectByHash& packet)
 	}
 }
 
-void Peer::recvPing(newcoin::TMPing& packet)
+void Peer::recvPing(ripple::TMPing& packet)
 {
 }
 
-void Peer::recvErrorMessage(newcoin::TMErrorMsg& packet)
+void Peer::recvErrorMessage(ripple::TMErrorMsg& packet)
 {
 }
 
-void Peer::recvSearchTransaction(newcoin::TMSearchTransaction& packet)
+void Peer::recvSearchTransaction(ripple::TMSearchTransaction& packet)
 {
 }
 
-void Peer::recvGetAccount(newcoin::TMGetAccount& packet)
+void Peer::recvGetAccount(ripple::TMGetAccount& packet)
 {
 }
 
-void Peer::recvAccount(newcoin::TMAccount& packet)
+void Peer::recvAccount(ripple::TMAccount& packet)
 {
 }
 
-void Peer::recvStatus(newcoin::TMStatusChange& packet)
+void Peer::recvStatus(ripple::TMStatusChange& packet)
 {
 	cLog(lsTRACE) << "Received status change from peer " << getIP();
 	if (!packet.has_networktime())
@@ -934,12 +934,12 @@ void Peer::recvStatus(newcoin::TMStatusChange& packet)
 		mLastStatus = packet;
 	else
 	{ // preserve old status
-		newcoin::NodeStatus status = mLastStatus.newstatus();
+		ripple::NodeStatus status = mLastStatus.newstatus();
 		mLastStatus = packet;
 		packet.set_newstatus(status);
 	}
 
-	if (packet.newevent() == newcoin::neLOST_SYNC)
+	if (packet.newevent() == ripple::neLOST_SYNC)
 	{
 		if (!mClosedLedgerHash.isZero())
 		{
@@ -969,13 +969,13 @@ void Peer::recvStatus(newcoin::TMStatusChange& packet)
 	else mPreviousLedgerHash.zero();
 }
 
-void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
+void Peer::recvGetLedger(ripple::TMGetLedger& packet)
 {
 	SHAMap::pointer map;
-	newcoin::TMLedgerData reply;
+	ripple::TMLedgerData reply;
 	bool fatLeaves = true, fatRoot = false;
 
-	if (packet.itype() == newcoin::liTS_CANDIDATE)
+	if (packet.itype() == ripple::liTS_CANDIDATE)
 	{ // Request is  for a transaction candidate set
 		cLog(lsINFO) << "Received request for TX candidate set data " << getIP();
 		if ((!packet.has_ledgerhash() || packet.ledgerhash().size() != 32))
@@ -994,7 +994,7 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
 		}
 		reply.set_ledgerseq(0);
 		reply.set_ledgerhash(txHash.begin(), txHash.size());
-		reply.set_type(newcoin::liTS_CANDIDATE);
+		reply.set_type(ripple::liTS_CANDIDATE);
 		fatLeaves = false; // We'll already have most transactions
 		fatRoot = true; // Save a pass
 	}
@@ -1017,9 +1017,9 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
 		}
 		else if (packet.has_ledgerseq())
 			ledger = theApp->getMasterLedger().getLedgerBySeq(packet.ledgerseq());
-		else if (packet.has_ltype() && (packet.ltype() == newcoin::ltCURRENT))
+		else if (packet.has_ltype() && (packet.ltype() == ripple::ltCURRENT))
 			ledger = theApp->getMasterLedger().getCurrentLedger();
-		else if (packet.has_ltype() && (packet.ltype() == newcoin::ltCLOSED) )
+		else if (packet.has_ltype() && (packet.ltype() == ripple::ltCLOSED) )
 		{
 			ledger = theApp->getMasterLedger().getClosedLedger();
 			if (ledger && !ledger->isClosed())
@@ -1045,7 +1045,7 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
 		reply.set_ledgerseq(ledger->getLedgerSeq());
 		reply.set_type(packet.itype());
 
-		if(packet.itype() == newcoin::liBASE)
+		if(packet.itype() == ripple::liBASE)
 		{ // they want the ledger base data
 			cLog(lsTRACE) << "Want ledger base data";
 			Serializer nData(128);
@@ -1076,13 +1076,13 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
 				}
 			}
 
-			PackedMessage::pointer oPacket = boost::make_shared<PackedMessage>(reply, newcoin::mtLEDGER_DATA);
+			PackedMessage::pointer oPacket = boost::make_shared<PackedMessage>(reply, ripple::mtLEDGER_DATA);
 			sendPacket(oPacket);
 			return;
 		}
 
-		if ((packet.itype() == newcoin::liTX_NODE) || (packet.itype() == newcoin::liAS_NODE))
-			map = (packet.itype() == newcoin::liTX_NODE) ?
+		if ((packet.itype() == ripple::liTX_NODE) || (packet.itype() == ripple::liAS_NODE))
+			map = (packet.itype() == ripple::liTX_NODE) ?
 				ledger->peekTransactionMap() : ledger->peekAccountStateMap();
 	}
 
@@ -1113,7 +1113,7 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
 			{
 				Serializer nID(33);
 				nodeIDIterator->addIDRaw(nID);
-				newcoin::TMLedgerNode* node = reply.add_nodes();
+				ripple::TMLedgerNode* node = reply.add_nodes();
 				node->set_nodeid(nID.getDataPtr(), nID.getLength());
 				node->set_nodedata(&rawNodeIterator->front(), rawNodeIterator->size());
 				++count;
@@ -1122,11 +1122,11 @@ void Peer::recvGetLedger(newcoin::TMGetLedger& packet)
 	}
 	if (packet.has_requestcookie())
 		reply.set_requestcookie(packet.requestcookie());
-	PackedMessage::pointer oPacket = boost::make_shared<PackedMessage>(reply, newcoin::mtLEDGER_DATA);
+	PackedMessage::pointer oPacket = boost::make_shared<PackedMessage>(reply, ripple::mtLEDGER_DATA);
 	sendPacket(oPacket);
 }
 
-void Peer::recvLedger(newcoin::TMLedgerData& packet)
+void Peer::recvLedger(ripple::TMLedgerData& packet)
 {
 	if (packet.nodes().size() <= 0)
 	{
@@ -1134,7 +1134,7 @@ void Peer::recvLedger(newcoin::TMLedgerData& packet)
 		return;
 	}
 
-	if (packet.type() == newcoin::liTS_CANDIDATE)
+	if (packet.type() == ripple::liTS_CANDIDATE)
 	{ // got data for a candidate transaction set
 		uint256 hash;
 		if(packet.ledgerhash().size() != 32)
@@ -1150,7 +1150,7 @@ void Peer::recvLedger(newcoin::TMLedgerData& packet)
 
 		for (int i = 0; i < packet.nodes().size(); ++i)
 		{
-			const newcoin::TMLedgerNode& node = packet.nodes(i);
+			const ripple::TMLedgerNode& node = packet.nodes(i);
 			if (!node.has_nodeid() || !node.has_nodedata() || (node.nodeid().size() != 33))
 			{
 				cLog(lsWARNING) << "LedgerData request with invalid node ID";
@@ -1244,7 +1244,7 @@ void Peer::sendHello()
 
 	theApp->getWallet().getNodePrivate().signNodePrivate(mCookieHash, vchSig);
 
-	newcoin::TMHello h;
+	ripple::TMHello h;
 
 	h.set_protoversion(MAKE_VERSION_INT(PROTO_VERSION_MAJOR, PROTO_VERSION_MINOR));
 	h.set_protoversionmin(MAKE_VERSION_INT(MIN_PROTO_MAJOR, MIN_PROTO_MINOR));
@@ -1263,18 +1263,18 @@ void Peer::sendHello()
 		h.set_ledgerprevious(hash.begin(), hash.GetSerializeSize());
 	}
 
-	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(h, newcoin::mtHELLO);
+	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(h, ripple::mtHELLO);
 	sendPacket(packet);
 }
 
 void Peer::sendGetPeers()
 {
 	// get other peers this guy knows about
-	newcoin::TMGetPeers getPeers;
+	ripple::TMGetPeers getPeers;
 
 	getPeers.set_doweneedthis(1);
 
-	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(getPeers, newcoin::mtGET_PEERS);
+	PackedMessage::pointer packet = boost::make_shared<PackedMessage>(getPeers, ripple::mtGET_PEERS);
 
 	sendPacket(packet);
 }
@@ -1308,11 +1308,11 @@ Json::Value Peer::getJson()
 	{
 		switch (mLastStatus.newstatus())
 		{
-			case newcoin::nsCONNECTING:		ret["status"] = "connecting";	break;
-			case newcoin::nsCONNECTED:		ret["status"] = "connected";	break;
-			case newcoin::nsMONITORING:		ret["status"] = "monitoring";	break;
-			case newcoin::nsVALIDATING:		ret["status"] = "validating";	break;
-			case newcoin::nsSHUTTING:		ret["status"] = "shutting";		break;
+			case ripple::nsCONNECTING:		ret["status"] = "connecting";	break;
+			case ripple::nsCONNECTED:		ret["status"] = "connected";	break;
+			case ripple::nsMONITORING:		ret["status"] = "monitoring";	break;
+			case ripple::nsVALIDATING:		ret["status"] = "validating";	break;
+			case ripple::nsSHUTTING:		ret["status"] = "shutting";		break;
 			default:						cLog(lsWARNING) << "Peer has unknown status: " << mLastStatus.newstatus();
 		}
 	}
diff --git a/src/Peer.h b/src/Peer.h
index a48e4c7228..c2fabfc591 100644
--- a/src/Peer.h
+++ b/src/Peer.h
@@ -65,8 +65,8 @@ protected:
 	std::vector<uint8_t> mReadbuf;
 	std::list<PackedMessage::pointer> mSendQ;
 	PackedMessage::pointer mSendingPacket;
-	newcoin::TMStatusChange mLastStatus;
-	newcoin::TMHello mHello;
+	ripple::TMStatusChange mLastStatus;
+	ripple::TMHello mHello;
 
 	Peer(boost::asio::io_service& io_service, boost::asio::ssl::context& ctx);
 
@@ -94,25 +94,25 @@ protected:
 
 	void sendHello();
 
-	void recvHello(newcoin::TMHello& packet);
-	void recvTransaction(newcoin::TMTransaction& packet);
-	void recvValidation(newcoin::TMValidation& packet);
-	void recvGetValidation(newcoin::TMGetValidations& packet);
-	void recvContact(newcoin::TMContact& packet);
-	void recvGetContacts(newcoin::TMGetContacts& packet);
-	void recvGetPeers(newcoin::TMGetPeers& packet);
-	void recvPeers(newcoin::TMPeers& packet);
-	void recvGetObjectByHash(newcoin::TMGetObjectByHash& packet);
-	void recvPing(newcoin::TMPing& packet);
-	void recvErrorMessage(newcoin::TMErrorMsg& packet);
-	void recvSearchTransaction(newcoin::TMSearchTransaction& packet);
-	void recvGetAccount(newcoin::TMGetAccount& packet);
-	void recvAccount(newcoin::TMAccount& packet);
-	void recvGetLedger(newcoin::TMGetLedger& packet);
-	void recvLedger(newcoin::TMLedgerData& packet);
-	void recvStatus(newcoin::TMStatusChange& packet);
-	void recvPropose(newcoin::TMProposeSet& packet);
-	void recvHaveTxSet(newcoin::TMHaveTransactionSet& packet);
+	void recvHello(ripple::TMHello& packet);
+	void recvTransaction(ripple::TMTransaction& packet);
+	void recvValidation(ripple::TMValidation& packet);
+	void recvGetValidation(ripple::TMGetValidations& packet);
+	void recvContact(ripple::TMContact& packet);
+	void recvGetContacts(ripple::TMGetContacts& packet);
+	void recvGetPeers(ripple::TMGetPeers& packet);
+	void recvPeers(ripple::TMPeers& packet);
+	void recvGetObjectByHash(ripple::TMGetObjectByHash& packet);
+	void recvPing(ripple::TMPing& packet);
+	void recvErrorMessage(ripple::TMErrorMsg& packet);
+	void recvSearchTransaction(ripple::TMSearchTransaction& packet);
+	void recvGetAccount(ripple::TMGetAccount& packet);
+	void recvAccount(ripple::TMAccount& packet);
+	void recvGetLedger(ripple::TMGetLedger& packet);
+	void recvLedger(ripple::TMLedgerData& packet);
+	void recvStatus(ripple::TMStatusChange& packet);
+	void recvPropose(ripple::TMProposeSet& packet);
+	void recvHaveTxSet(ripple::TMHaveTransactionSet& packet);
 
 	void getSessionCookie(std::string& strDst);
 
diff --git a/src/ripple.proto b/src/ripple.proto
index 743ab55eaa..a6ed14e55c 100644
--- a/src/ripple.proto
+++ b/src/ripple.proto
@@ -1,4 +1,4 @@
-package newcoin;
+package ripple;
 
 enum MessageType {
 // core