Remove all IField/ITField functions. They are now obsolete.

Use the correponding STObject functions.
2025-12-06 17:27:55 +00:00 · 2012-10-01 15:21:22 -07:00
parent 841a404114
commit 79c35f2689
21 changed files with 289 additions and 364 deletions
--- a/src/AccountState.cpp
+++ b/src/AccountState.cpp
@@ -17,7 +17,7 @@ AccountState::AccountState(const NewcoinAddress& naAccountID) : mAccountID(naAcc

 	mLedgerEntry = boost::make_shared<SerializedLedgerEntry>(ltACCOUNT_ROOT);
 	mLedgerEntry->setIndex(Ledger::getAccountRootIndex(naAccountID));
-	mLedgerEntry->setIFieldAccount(sfAccount, naAccountID.getAccountID());
+	mLedgerEntry->setValueFieldAccount(sfAccount, naAccountID.getAccountID());

 	mValid = true;
 }
@@ -48,8 +48,8 @@ void AccountState::addJson(Json::Value& val)

 	if (mValid)
 	{
-		if (mLedgerEntry->getIFieldPresent(sfEmailHash))
-			val["UrlGravatar"]	= createGravatarUrl(mLedgerEntry->getIFieldH128(sfEmailHash));
+		if (mLedgerEntry->isFieldPresent(sfEmailHash))
+			val["UrlGravatar"]	= createGravatarUrl(mLedgerEntry->getValueFieldH128(sfEmailHash));
 	}
 	else
 	{
--- a/src/AccountState.h
+++ b/src/AccountState.h
@@ -33,16 +33,16 @@ public:

 	bool	bHaveAuthorizedKey()
 	{
-		return mLedgerEntry->getIFieldPresent(sfAuthorizedKey);
+		return mLedgerEntry->isFieldPresent(sfAuthorizedKey);
 	}

 	NewcoinAddress getAuthorizedKey()
 	{
-		return mLedgerEntry->getIValueFieldAccount(sfAuthorizedKey);
+		return mLedgerEntry->getValueFieldAccount(sfAuthorizedKey);
 	}

-	STAmount getBalance() const { return mLedgerEntry->getIValueFieldAmount(sfBalance); }
-	uint32 getSeq() const { return mLedgerEntry->getIFieldU32(sfSequence); }
+	STAmount getBalance() const { return mLedgerEntry->getValueFieldAmount(sfBalance); }
+	uint32 getSeq() const { return mLedgerEntry->getValueFieldU32(sfSequence); }

 	SerializedLedgerEntry::pointer getSLE() { return mLedgerEntry; }
 	const SerializedLedgerEntry& peekSLE() const { return *mLedgerEntry; }
--- a/src/Ledger.cpp
+++ b/src/Ledger.cpp
@@ -27,8 +27,8 @@ Ledger::Ledger(const NewcoinAddress& masterID, uint64 startAmount) : mTotCoins(s
 {
 	// special case: put coins in root account
 	AccountState::pointer startAccount = boost::make_shared<AccountState>(masterID);
-	startAccount->peekSLE().setIFieldAmount(sfBalance, startAmount);
-	startAccount->peekSLE().setIFieldU32(sfSequence, 1);
+	startAccount->peekSLE().setValueFieldAmount(sfBalance, startAmount);
+	startAccount->peekSLE().setValueFieldU32(sfSequence, 1);
 	writeBack(lepCREATE, startAccount->getSLE());
 #if 0
 	std::cerr << "Root account:";
--- a/src/LedgerEntrySet.cpp
+++ b/src/LedgerEntrySet.cpp
@@ -383,28 +383,28 @@ void LedgerEntrySet::calcRawMeta(Serializer& s)
 			assert(origNode);
 			threadOwners(origNode, mLedger, newMod);

-			if (origNode->getIFieldPresent(sfAmount))
+			if (origNode->isFieldPresent(sfAmount))
 			{ // node has an amount, covers ripple state nodes
-				STAmount amount = origNode->getIValueFieldAmount(sfAmount);
+				STAmount amount = origNode->getValueFieldAmount(sfAmount);
 				if (amount.isNonZero())
 					metaNode.addAmount(TMSPrevBalance, amount);
-				amount = curNode->getIValueFieldAmount(sfAmount);
+				amount = curNode->getValueFieldAmount(sfAmount);
 				if (amount.isNonZero())
 					metaNode.addAmount(TMSFinalBalance, amount);

 				if (origNode->getType() == ltRIPPLE_STATE)
 				{
-					metaNode.addAccount(TMSLowID, NewcoinAddress::createAccountID(origNode->getIValueFieldAmount(sfLowLimit).getIssuer()));
-					metaNode.addAccount(TMSHighID, NewcoinAddress::createAccountID(origNode->getIValueFieldAmount(sfHighLimit).getIssuer()));
+					metaNode.addAccount(TMSLowID, NewcoinAddress::createAccountID(origNode->getValueFieldAmount(sfLowLimit).getIssuer()));
+					metaNode.addAccount(TMSHighID, NewcoinAddress::createAccountID(origNode->getValueFieldAmount(sfHighLimit).getIssuer()));
 				}
 			}

 			if (origNode->getType() == ltOFFER)
 			{ // check for non-zero balances
-				STAmount amount = origNode->getIValueFieldAmount(sfTakerPays);
+				STAmount amount = origNode->getValueFieldAmount(sfTakerPays);
 				if (amount.isNonZero())
 					metaNode.addAmount(TMSFinalTakerPays, amount);
-				amount = origNode->getIValueFieldAmount(sfTakerGets);
+				amount = origNode->getValueFieldAmount(sfTakerGets);
 				if (amount.isNonZero())
 					metaNode.addAmount(TMSFinalTakerGets, amount);
 			}
@@ -429,20 +429,20 @@ void LedgerEntrySet::calcRawMeta(Serializer& s)
 		if (nType == TMNModifiedNode)
 		{
 			assert(origNode);
-			if (origNode->getIFieldPresent(sfAmount))
+			if (origNode->isFieldPresent(sfAmount))
 			{ // node has an amount, covers account root nodes and ripple nodes
-				STAmount amount = origNode->getIValueFieldAmount(sfAmount);
-				if (amount != curNode->getIValueFieldAmount(sfAmount))
+				STAmount amount = origNode->getValueFieldAmount(sfAmount);
+				if (amount != curNode->getValueFieldAmount(sfAmount))
 					metaNode.addAmount(TMSPrevBalance, amount);
 			}

 			if (origNode->getType() == ltOFFER)
 			{
-				STAmount amount = origNode->getIValueFieldAmount(sfTakerPays);
-				if (amount != curNode->getIValueFieldAmount(sfTakerPays))
+				STAmount amount = origNode->getValueFieldAmount(sfTakerPays);
+				if (amount != curNode->getValueFieldAmount(sfTakerPays))
 					metaNode.addAmount(TMSPrevTakerPays, amount);
-				amount = origNode->getIValueFieldAmount(sfTakerGets);
-				if (amount != curNode->getIValueFieldAmount(sfTakerGets))
+				amount = origNode->getValueFieldAmount(sfTakerGets);
+				if (amount != curNode->getValueFieldAmount(sfTakerGets))
 					metaNode.addAmount(TMSPrevTakerGets, amount);
 			}

@@ -485,7 +485,7 @@ TER LedgerEntrySet::dirAdd(
 	}
 	else
 	{
-		uNodeDir	= sleRoot->getIFieldU64(sfIndexPrevious);		// Get index to last directory node.
+		uNodeDir	= sleRoot->getValueFieldU64(sfIndexPrevious);		// Get index to last directory node.

 		if (uNodeDir)
 		{
@@ -500,7 +500,7 @@ TER LedgerEntrySet::dirAdd(
 			sleNode		= sleRoot;
 		}

-		svIndexes	= sleNode->getIFieldV256(sfIndexes);
+		svIndexes	= sleNode->getValueFieldV256(sfIndexes);

 		if (DIR_NODE_MAX != svIndexes.peekValue().size())
 		{
@@ -519,7 +519,7 @@ TER LedgerEntrySet::dirAdd(
 			{
 				// Previous node is root node.

-				sleRoot->setIFieldU64(sfIndexNext, uNodeDir);
+				sleRoot->setValueFieldU64(sfIndexNext, uNodeDir);
 			}
 			else
 			{
@@ -527,14 +527,14 @@ TER LedgerEntrySet::dirAdd(

 				SLE::pointer	slePrevious	= entryCache(ltDIR_NODE, Ledger::getDirNodeIndex(uRootIndex, uNodeDir-1));

-				slePrevious->setIFieldU64(sfIndexNext, uNodeDir);
+				slePrevious->setValueFieldU64(sfIndexNext, uNodeDir);
 				entryModify(slePrevious);

-				sleNode->setIFieldU64(sfIndexPrevious, uNodeDir-1);
+				sleNode->setValueFieldU64(sfIndexPrevious, uNodeDir-1);
 			}

 			// Have root point to new node.
-			sleRoot->setIFieldU64(sfIndexPrevious, uNodeDir);
+			sleRoot->setValueFieldU64(sfIndexPrevious, uNodeDir);
 			entryModify(sleRoot);

 			// Create the new node.
@@ -544,7 +544,7 @@ TER LedgerEntrySet::dirAdd(
 	}

 	svIndexes.peekValue().push_back(uLedgerIndex);	// Append entry.
-	sleNode->setIFieldV256(sfIndexes, svIndexes);	// Save entry.
+	sleNode->setValueFieldV256(sfIndexes, svIndexes);	// Save entry.

 	Log(lsINFO) << "dirAdd:   creating: root: " << uRootIndex.ToString();
 	Log(lsINFO) << "dirAdd:  appending: Entry: " << uLedgerIndex.ToString();
@@ -574,7 +574,7 @@ TER LedgerEntrySet::dirDelete(
 		return tefBAD_LEDGER;
 	}

-	STVector256						svIndexes	= sleNode->getIFieldV256(sfIndexes);
+	STVector256						svIndexes	= sleNode->getValueFieldV256(sfIndexes);
 	std::vector<uint256>&			vuiIndexes	= svIndexes.peekValue();
 	std::vector<uint256>::iterator	it;

@@ -608,14 +608,14 @@ TER LedgerEntrySet::dirDelete(
 		vuiIndexes.clear();
 	}

-	sleNode->setIFieldV256(sfIndexes, svIndexes);
+	sleNode->setValueFieldV256(sfIndexes, svIndexes);
 	entryModify(sleNode);

 	if (vuiIndexes.empty())
 	{
 		// May be able to delete nodes.
-		uint64				uNodePrevious	= sleNode->getIFieldU64(sfIndexPrevious);
-		uint64				uNodeNext		= sleNode->getIFieldU64(sfIndexNext);
+		uint64				uNodePrevious	= sleNode->getValueFieldU64(sfIndexPrevious);
+		uint64				uNodeNext		= sleNode->getValueFieldU64(sfIndexNext);

 		if (!uNodeCur)
 		{
@@ -646,7 +646,7 @@ TER LedgerEntrySet::dirDelete(

 				assert(sleLast);

-				if (sleLast->getIFieldV256(sfIndexes).peekValue().empty())
+				if (sleLast->getValueFieldV256(sfIndexes).peekValue().empty())
 				{
 					// Both nodes are empty.

@@ -690,11 +690,11 @@ TER LedgerEntrySet::dirDelete(
 			}

 			// Fix previous to point to its new next.
-			slePrevious->setIFieldU64(sfIndexNext, uNodeNext);
+			slePrevious->setValueFieldU64(sfIndexNext, uNodeNext);
 			entryModify(slePrevious);

 			// Fix next to point to its new previous.
-			sleNext->setIFieldU64(sfIndexPrevious, uNodePrevious);
+			sleNext->setValueFieldU64(sfIndexPrevious, uNodePrevious);
 			entryModify(sleNext);
 		}
 		// Last node.
@@ -712,7 +712,7 @@ TER LedgerEntrySet::dirDelete(

 			assert(sleRoot);

-			if (sleRoot->getIFieldV256(sfIndexes).peekValue().empty())
+			if (sleRoot->getValueFieldV256(sfIndexes).peekValue().empty())
 			{
 				// Both nodes are empty.

@@ -755,12 +755,12 @@ bool LedgerEntrySet::dirNext(
 	unsigned int& uDirEntry,	// <-> next entry
 	uint256& uEntryIndex)		// <-- The entry, if available. Otherwise, zero.
 {
-	STVector256				svIndexes	= sleNode->getIFieldV256(sfIndexes);
+	STVector256				svIndexes	= sleNode->getValueFieldV256(sfIndexes);
 	std::vector<uint256>&	vuiIndexes	= svIndexes.peekValue();

 	if (uDirEntry == vuiIndexes.size())
 	{
-		uint64				uNodeNext	= sleNode->getIFieldU64(sfIndexNext);
+		uint64				uNodeNext	= sleNode->getValueFieldU64(sfIndexNext);

 		if (!uNodeNext)
 		{
@@ -785,13 +785,13 @@ Log(lsINFO) << boost::str(boost::format("dirNext: uDirEntry=%d uEntryIndex=%s")

 TER LedgerEntrySet::offerDelete(const SLE::pointer& sleOffer, const uint256& uOfferIndex, const uint160& uOwnerID)
 {
-	uint64	uOwnerNode	= sleOffer->getIFieldU64(sfOwnerNode);
+	uint64	uOwnerNode	= sleOffer->getValueFieldU64(sfOwnerNode);
 	TER		terResult	= dirDelete(false, uOwnerNode, Ledger::getOwnerDirIndex(uOwnerID), uOfferIndex, false);

 	if (tesSUCCESS == terResult)
 	{
-		uint256		uDirectory	= sleOffer->getIFieldH256(sfBookDirectory);
-		uint64		uBookNode	= sleOffer->getIFieldU64(sfBookNode);
+		uint256		uDirectory	= sleOffer->getValueFieldH256(sfBookDirectory);
+		uint64		uBookNode	= sleOffer->getValueFieldU64(sfBookNode);

 		terResult	= dirDelete(false, uBookNode, uDirectory, uOfferIndex, true);
 	}
@@ -804,7 +804,7 @@ TER LedgerEntrySet::offerDelete(const SLE::pointer& sleOffer, const uint256& uOf
 TER LedgerEntrySet::offerDelete(const uint256& uOfferIndex)
 {
 	SLE::pointer	sleOffer	= entryCache(ltOFFER, uOfferIndex);
-	const uint160	uOwnerID	= sleOffer->getIValueFieldAccount(sfAccount).getAccountID();
+	const uint160	uOwnerID	= sleOffer->getValueFieldAccount(sfAccount).getAccountID();

 	return offerDelete(sleOffer, uOfferIndex, uOwnerID);
 }
@@ -818,7 +818,7 @@ STAmount LedgerEntrySet::rippleOwed(const uint160& uToAccountID, const uint160&

 	if (sleRippleState)
 	{
-		saBalance	= sleRippleState->getIValueFieldAmount(sfBalance);
+		saBalance	= sleRippleState->getValueFieldAmount(sfBalance);
 		if (uToAccountID < uFromAccountID)
 			saBalance.negate();
 		saBalance.setIssuer(uToAccountID);
@@ -849,7 +849,7 @@ STAmount LedgerEntrySet::rippleLimit(const uint160& uToAccountID, const uint160&
 	assert(sleRippleState);
 	if (sleRippleState)
 	{
-		saLimit	= sleRippleState->getIValueFieldAmount(uToAccountID < uFromAccountID ? sfLowLimit : sfHighLimit);
+		saLimit	= sleRippleState->getValueFieldAmount(uToAccountID < uFromAccountID ? sfLowLimit : sfHighLimit);
 		saLimit.setIssuer(uToAccountID);
 	}

@@ -861,8 +861,8 @@ uint32 LedgerEntrySet::rippleTransferRate(const uint160& uIssuerID)
 {
 	SLE::pointer	sleAccount	= entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uIssuerID));

-	uint32			uQuality	= sleAccount && sleAccount->getIFieldPresent(sfTransferRate)
-									? sleAccount->getIFieldU32(sfTransferRate)
+	uint32			uQuality	= sleAccount && sleAccount->isFieldPresent(sfTransferRate)
+									? sleAccount->getValueFieldU32(sfTransferRate)
 									: QUALITY_ONE;

 	Log(lsINFO) << boost::str(boost::format("rippleTransferRate: uIssuerID=%s account_exists=%d transfer_rate=%f")
@@ -893,8 +893,8 @@ uint32 LedgerEntrySet::rippleQualityIn(const uint160& uToAccountID, const uint16
 		{
 			SField::ref	sfField	= uToAccountID < uFromAccountID ? sfLow: sfHigh;

-			uQuality	= sleRippleState->getIFieldPresent(sfField)
-							? sleRippleState->getIFieldU32(sfField)
+			uQuality	= sleRippleState->isFieldPresent(sfField)
+							? sleRippleState->getValueFieldU32(sfField)
 							: QUALITY_ONE;

 			if (!uQuality)
@@ -924,7 +924,7 @@ STAmount LedgerEntrySet::rippleHolds(const uint160& uAccountID, const uint160& u

 	if (sleRippleState)
 	{
-		saBalance	= sleRippleState->getIValueFieldAmount(sfBalance);
+		saBalance	= sleRippleState->getValueFieldAmount(sfBalance);

 		if (uAccountID > uIssuerID)
 			saBalance.negate();		// Put balance in uAccountID terms.
@@ -942,7 +942,7 @@ STAmount LedgerEntrySet::accountHolds(const uint160& uAccountID, const uint160&
 	{
 		SLE::pointer	sleAccount	= entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uAccountID));

-		saAmount	= sleAccount->getIValueFieldAmount(sfBalance);
+		saAmount	= sleAccount->getValueFieldAmount(sfBalance);
 	}
 	else
 	{
@@ -1031,13 +1031,13 @@ void LedgerEntrySet::rippleCredit(const uint160& uSenderID, const uint160& uRece
 		if (!bFlipped)
 			saBalance.negate();

-		sleRippleState->setIFieldAmount(sfBalance, saBalance);
-		sleRippleState->setIFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, STAmount(uCurrencyID, uSenderID));
-		sleRippleState->setIFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uReceiverID));
+		sleRippleState->setValueFieldAmount(sfBalance, saBalance);
+		sleRippleState->setValueFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, STAmount(uCurrencyID, uSenderID));
+		sleRippleState->setValueFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uReceiverID));
 	}
 	else
 	{
-		STAmount	saBalance	= sleRippleState->getIValueFieldAmount(sfBalance);
+		STAmount	saBalance	= sleRippleState->getValueFieldAmount(sfBalance);

 		if (!bFlipped)
 			saBalance.negate();		// Put balance in low terms.
@@ -1047,7 +1047,7 @@ void LedgerEntrySet::rippleCredit(const uint160& uSenderID, const uint160& uRece
 		if (!bFlipped)
 			saBalance.negate();

-		sleRippleState->setIFieldAmount(sfBalance, saBalance);
+		sleRippleState->setValueFieldAmount(sfBalance, saBalance);

 		entryModify(sleRippleState);
 	}
@@ -1106,28 +1106,28 @@ void LedgerEntrySet::accountSend(const uint160& uSenderID, const uint160& uRecei

 		Log(lsINFO) << boost::str(boost::format("accountSend> %s (%s) -> %s (%s) : %s")
 			% NewcoinAddress::createHumanAccountID(uSenderID)
-			% (sleSender ? (sleSender->getIValueFieldAmount(sfBalance)).getFullText() : "-")
+			% (sleSender ? (sleSender->getValueFieldAmount(sfBalance)).getFullText() : "-")
 			% NewcoinAddress::createHumanAccountID(uReceiverID)
-			% (sleReceiver ? (sleReceiver->getIValueFieldAmount(sfBalance)).getFullText() : "-")
+			% (sleReceiver ? (sleReceiver->getValueFieldAmount(sfBalance)).getFullText() : "-")
 			% saAmount.getFullText());

 		if (sleSender)
 		{
-			sleSender->setIFieldAmount(sfBalance, sleSender->getIValueFieldAmount(sfBalance) - saAmount);
+			sleSender->setValueFieldAmount(sfBalance, sleSender->getValueFieldAmount(sfBalance) - saAmount);
 			entryModify(sleSender);
 		}

 		if (sleReceiver)
 		{
-			sleReceiver->setIFieldAmount(sfBalance, sleReceiver->getIValueFieldAmount(sfBalance) + saAmount);
+			sleReceiver->setValueFieldAmount(sfBalance, sleReceiver->getValueFieldAmount(sfBalance) + saAmount);
 			entryModify(sleReceiver);
 		}

 		Log(lsINFO) << boost::str(boost::format("accountSend< %s (%s) -> %s (%s) : %s")
 			% NewcoinAddress::createHumanAccountID(uSenderID)
-			% (sleSender ? (sleSender->getIValueFieldAmount(sfBalance)).getFullText() : "-")
+			% (sleSender ? (sleSender->getValueFieldAmount(sfBalance)).getFullText() : "-")
 			% NewcoinAddress::createHumanAccountID(uReceiverID)
-			% (sleReceiver ? (sleReceiver->getIValueFieldAmount(sfBalance)).getFullText() : "-")
+			% (sleReceiver ? (sleReceiver->getValueFieldAmount(sfBalance)).getFullText() : "-")
 			% saAmount.getFullText());
 	}
 	else
--- a/src/NetworkOPs.cpp
+++ b/src/NetworkOPs.cpp
@@ -245,12 +245,12 @@ STVector256 NetworkOPs::getDirNodeInfo(
 	{
 		Log(lsDEBUG) << "getDirNodeInfo: node index: " << uNodeIndex.ToString();

-		Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(sleNode->getIFieldU64(sfIndexPrevious));
-		Log(lsTRACE) << "getDirNodeInfo:  last: " << strHex(sleNode->getIFieldU64(sfIndexNext));
+		Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(sleNode->getValueFieldU64(sfIndexPrevious));
+		Log(lsTRACE) << "getDirNodeInfo:  last: " << strHex(sleNode->getValueFieldU64(sfIndexNext));

-		uNodePrevious	= sleNode->getIFieldU64(sfIndexPrevious);
-		uNodeNext		= sleNode->getIFieldU64(sfIndexNext);
-		svIndexes		= sleNode->getIFieldV256(sfIndexes);
+		uNodePrevious	= sleNode->getValueFieldU64(sfIndexPrevious);
+		uNodeNext		= sleNode->getValueFieldU64(sfIndexNext);
+		svIndexes		= sleNode->getValueFieldV256(sfIndexes);

 		Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(uNodePrevious);
 		Log(lsTRACE) << "getDirNodeInfo:  last: " << strHex(uNodeNext);
@@ -299,7 +299,7 @@ Json::Value NetworkOPs::getOwnerInfo(Ledger::pointer lpLedger, const NewcoinAddr

 		do
 		{
-			STVector256					svIndexes	= sleNode->getIFieldV256(sfIndexes);
+			STVector256					svIndexes	= sleNode->getValueFieldV256(sfIndexes);
 			const std::vector<uint256>&	vuiIndexes	= svIndexes.peekValue();

 			BOOST_FOREACH(const uint256& uDirEntry, vuiIndexes)
@@ -332,7 +332,7 @@ Json::Value NetworkOPs::getOwnerInfo(Ledger::pointer lpLedger, const NewcoinAddr
 				}
 			}

-			uNodeDir		= sleNode->getIFieldU64(sfIndexNext);
+			uNodeDir		= sleNode->getValueFieldU64(sfIndexNext);
 			if (uNodeDir)
 			{
 				lspNode	= lepNONE;
--- a/src/NicknameState.cpp
+++ b/src/NicknameState.cpp
@@ -8,19 +8,19 @@ NicknameState::NicknameState(SerializedLedgerEntry::pointer ledgerEntry) :

 bool NicknameState::haveMinimumOffer() const
 {
-    return mLedgerEntry->getIFieldPresent(sfMinimumOffer);
+    return mLedgerEntry->isFieldPresent(sfMinimumOffer);
 }

 STAmount NicknameState::getMinimumOffer() const
 {
-    return mLedgerEntry->getIFieldPresent(sfMinimumOffer)
-	? mLedgerEntry->getIValueFieldAmount(sfMinimumOffer)
+    return mLedgerEntry->isFieldPresent(sfMinimumOffer)
+	? mLedgerEntry->getValueFieldAmount(sfMinimumOffer)
 	: STAmount();
 }

 NewcoinAddress NicknameState::getAccountID() const
 {
-    return mLedgerEntry->getIValueFieldAccount(sfAccount);
+    return mLedgerEntry->getValueFieldAccount(sfAccount);
 }

 void NicknameState::addJson(Json::Value& val)
--- a/src/OrderBook.cpp
+++ b/src/OrderBook.cpp
@@ -10,8 +10,8 @@ OrderBook::pointer OrderBook::newOrderBook(SerializedLedgerEntry::pointer ledger

 OrderBook::OrderBook(SerializedLedgerEntry::pointer ledgerEntry)
 {
-	const STAmount	saTakerGets	= ledgerEntry->getIValueFieldAmount(sfTakerGets);
-	const STAmount	saTakerPays	= ledgerEntry->getIValueFieldAmount(sfTakerPays);
+	const STAmount	saTakerGets	= ledgerEntry->getValueFieldAmount(sfTakerGets);
+	const STAmount	saTakerPays	= ledgerEntry->getValueFieldAmount(sfTakerPays);

 	mCurrencyIn		= saTakerGets.getCurrency();
 	mCurrencyOut	= saTakerPays.getCurrency();
--- a/src/RPCServer.cpp
+++ b/src/RPCServer.cpp
@@ -252,7 +252,7 @@ Json::Value RPCServer::getMasterGenerator(const uint256& uLedger, const NewcoinA
 		return RPCError(rpcNO_ACCOUNT);
 	}

-	std::vector<unsigned char>	vucCipher			= sleGen->getIFieldVL(sfGenerator);
+	std::vector<unsigned char>	vucCipher			= sleGen->getValueFieldVL(sfGenerator);
 	std::vector<unsigned char>	vucMasterGenerator	= na0Private.accountPrivateDecrypt(na0Public, vucCipher);
 	if (vucMasterGenerator.empty())
 	{
@@ -402,7 +402,7 @@ Json::Value RPCServer::accountFromString(const uint256& uLedger, NewcoinAddress&
 		else
 		{
 			// Found master public key.
-			std::vector<unsigned char>	vucCipher				= sleGen->getIFieldVL(sfGenerator);
+			std::vector<unsigned char>	vucCipher				= sleGen->getValueFieldVL(sfGenerator);
 			std::vector<unsigned char>	vucMasterGenerator		= naRegular0Private.accountPrivateDecrypt(naRegular0Public, vucCipher);
 			if (vucMasterGenerator.empty())
 			{
--- a/src/RippleCalc.cpp
+++ b/src/RippleCalc.cpp
@@ -116,8 +116,8 @@ TER RippleCalc::calcNodeAdvance(
 		{
 			if (bFundsDirty)
 			{
-				saTakerPays		= sleOffer->getIValueFieldAmount(sfTakerPays);
-				saTakerGets		= sleOffer->getIValueFieldAmount(sfTakerGets);
+				saTakerPays		= sleOffer->getValueFieldAmount(sfTakerPays);
+				saTakerGets		= sleOffer->getValueFieldAmount(sfTakerGets);

 				saOfferFunds	= lesActive.accountFunds(uOfrOwnerID, saTakerGets);	// Funds left.
 				bFundsDirty		= false;
@@ -153,13 +153,13 @@ TER RippleCalc::calcNodeAdvance(
 		{
 			// Got a new offer.
 			sleOffer	= lesActive.entryCache(ltOFFER, uOfferIndex);
-			uOfrOwnerID = sleOffer->getIValueFieldAccount(sfAccount).getAccountID();
+			uOfrOwnerID = sleOffer->getValueFieldAccount(sfAccount).getAccountID();

 			const aciSource			asLine				= boost::make_tuple(uOfrOwnerID, uCurCurrencyID, uCurIssuerID);

 			Log(lsINFO) << boost::str(boost::format("calcNodeAdvance: uOfrOwnerID=%s") % NewcoinAddress::createHumanAccountID(uOfrOwnerID));

-			if (sleOffer->getIFieldPresent(sfExpiration) && sleOffer->getIFieldU32(sfExpiration) <= lesActive.getLedger()->getParentCloseTimeNC())
+			if (sleOffer->isFieldPresent(sfExpiration) && sleOffer->getValueFieldU32(sfExpiration) <= lesActive.getLedger()->getParentCloseTimeNC())
 			{
 				// Offer is expired.
 				Log(lsINFO) << "calcNodeAdvance: expired offer";
@@ -207,8 +207,8 @@ TER RippleCalc::calcNodeAdvance(
 				continue;
 			}

-			saTakerPays		= sleOffer->getIValueFieldAmount(sfTakerPays);
-			saTakerGets		= sleOffer->getIValueFieldAmount(sfTakerGets);
+			saTakerPays		= sleOffer->getValueFieldAmount(sfTakerPays);
+			saTakerGets		= sleOffer->getValueFieldAmount(sfTakerGets);

 			saOfferFunds	= lesActive.accountFunds(uOfrOwnerID, saTakerGets);	// Funds left.

@@ -430,8 +430,8 @@ TER RippleCalc::calcNodeDeliverRev(
 		lesActive.accountSend(uOfrOwnerID, uCurIssuerID, saOutPass);

 		// Adjust offer
-		sleOffer->setIFieldAmount(sfTakerGets, saTakerGets - saOutPass);
-		sleOffer->setIFieldAmount(sfTakerPays, saTakerPays - saInPassAct);
+		sleOffer->setValueFieldAmount(sfTakerGets, saTakerGets - saOutPass);
+		sleOffer->setValueFieldAmount(sfTakerPays, saTakerPays - saInPassAct);

 		lesActive.entryModify(sleOffer);

@@ -580,8 +580,8 @@ TER RippleCalc::calcNodeDeliverFwd(
 			lesActive.accountSend(uInAccountID, uOfrOwnerID, saInPassAct);

 			// Adjust offer
-			sleOffer->setIFieldAmount(sfTakerGets, saTakerGets - saOutPassAct);
-			sleOffer->setIFieldAmount(sfTakerPays, saTakerPays - saInPassAct);
+			sleOffer->setValueFieldAmount(sfTakerGets, saTakerGets - saOutPassAct);
+			sleOffer->setValueFieldAmount(sfTakerPays, saTakerPays - saInPassAct);

 			lesActive.entryModify(sleOffer);

@@ -2092,11 +2092,11 @@ void TransactionEngine::calcOfferBridgeNext(

 		SLE::pointer	sleOffer		= entryCache(ltOFFER, uOfferIndex);

-		uint160			uOfferOwnerID	= sleOffer->getIValueFieldAccount(sfAccount).getAccountID();
-		STAmount		saOfferPays		= sleOffer->getIValueFieldAmount(sfTakerGets);
-		STAmount		saOfferGets		= sleOffer->getIValueFieldAmount(sfTakerPays);
+		uint160			uOfferOwnerID	= sleOffer->getValueFieldAccount(sfAccount).getAccountID();
+		STAmount		saOfferPays		= sleOffer->getValueFieldAmount(sfTakerGets);
+		STAmount		saOfferGets		= sleOffer->getValueFieldAmount(sfTakerPays);

-		if (sleOffer->getIFieldPresent(sfExpiration) && sleOffer->getIFieldU32(sfExpiration) <= mLedger->getParentCloseTimeNC())
+		if (sleOffer->isFieldPresent(sfExpiration) && sleOffer->getValueFieldU32(sfExpiration) <= mLedger->getParentCloseTimeNC())
 		{
 			// Offer is expired.
 			Log(lsINFO) << "calcOfferFirst: encountered expired offer";
--- a/src/RippleLines.cpp
+++ b/src/RippleLines.cpp
@@ -25,7 +25,7 @@ void RippleLines::fillLines(const uint160& accountID, Ledger::pointer ledger)
 		SLE::pointer rippleDir=ledger->getDirNode(lspNode, currentIndex);
 		if (!rippleDir) return;

-		STVector256 svOwnerNodes		= rippleDir->getIFieldV256(sfIndexes);
+		STVector256 svOwnerNodes		= rippleDir->getValueFieldV256(sfIndexes);
 		BOOST_FOREACH(uint256& uNode, svOwnerNodes.peekValue())
 		{
 			SLE::pointer	sleCur	= ledger->getSLE(uNode);
@@ -45,7 +45,7 @@ void RippleLines::fillLines(const uint160& accountID, Ledger::pointer ledger)
 			}
 		}

-		uint64 uNodeNext	= rippleDir->getIFieldU64(sfIndexNext);
+		uint64 uNodeNext	= rippleDir->getValueFieldU64(sfIndexNext);
 		if (!uNodeNext) return;

 		currentIndex	= Ledger::getDirNodeIndex(rootIndex, uNodeNext);
--- a/src/RippleState.cpp
+++ b/src/RippleState.cpp
@@ -7,19 +7,19 @@ RippleState::RippleState(SerializedLedgerEntry::pointer ledgerEntry) :
 {
 	if (!mLedgerEntry || mLedgerEntry->getType() != ltRIPPLE_STATE) return;

-	mLowLimit		= mLedgerEntry->getIValueFieldAmount(sfLowLimit);
-	mHighLimit		= mLedgerEntry->getIValueFieldAmount(sfHighLimit);
+	mLowLimit		= mLedgerEntry->getValueFieldAmount(sfLowLimit);
+	mHighLimit		= mLedgerEntry->getValueFieldAmount(sfHighLimit);

 	mLowID			= NewcoinAddress::createAccountID(mLowLimit.getIssuer());
 	mHighID			= NewcoinAddress::createAccountID(mHighLimit.getIssuer());

-	mLowQualityIn	= mLedgerEntry->getIFieldU32(sfLowQualityIn);
-	mLowQualityOut	= mLedgerEntry->getIFieldU32(sfLowQualityOut);
+	mLowQualityIn	= mLedgerEntry->getValueFieldU32(sfLowQualityIn);
+	mLowQualityOut	= mLedgerEntry->getValueFieldU32(sfLowQualityOut);

-	mHighQualityIn	= mLedgerEntry->getIFieldU32(sfHighQualityIn);
-	mHighQualityOut	= mLedgerEntry->getIFieldU32(sfHighQualityOut);
+	mHighQualityIn	= mLedgerEntry->getValueFieldU32(sfHighQualityIn);
+	mHighQualityOut	= mLedgerEntry->getValueFieldU32(sfHighQualityOut);

-	mBalance	= mLedgerEntry->getIValueFieldAmount(sfBalance);
+	mBalance	= mLedgerEntry->getValueFieldAmount(sfBalance);

 	mValid		= true;
 }
--- a/src/SerializedLedger.cpp
+++ b/src/SerializedLedger.cpp
@@ -124,12 +124,12 @@ NewcoinAddress SerializedLedgerEntry::getOwner()

 NewcoinAddress SerializedLedgerEntry::getFirstOwner()
 {
-	return NewcoinAddress::createAccountID(getIValueFieldAmount(sfLowLimit).getIssuer());
+	return NewcoinAddress::createAccountID(getValueFieldAmount(sfLowLimit).getIssuer());
 }

 NewcoinAddress SerializedLedgerEntry::getSecondOwner()
 {
-	return NewcoinAddress::createAccountID(getIValueFieldAmount(sfHighLimit).getIssuer());
+	return NewcoinAddress::createAccountID(getValueFieldAmount(sfHighLimit).getIssuer());
 }

 std::vector<uint256> SerializedLedgerEntry::getOwners()
--- a/src/SerializedLedger.h
+++ b/src/SerializedLedger.h
@@ -46,50 +46,6 @@ public:
 	uint32 getThreadedLedger();
 	bool thread(const uint256& txID, uint32 ledgerSeq, uint256& prevTxID, uint32& prevLedgerID);
 	std::vector<uint256> getOwners();	// nodes notified if this node is deleted
-
-	// CAUTION: All these functions are now obsolete and will be removed after
-	// the new serialization code is merged.
-	int getIFieldIndex(SField::ref field) const { return getFieldIndex(field); }
-	int getIFieldCount() const { return getCount(); }
-	const SerializedType& peekIField(SField::ref field) const { return peekAtField(field); }
-	SerializedType& getIField(SField::ref field) { return getField(field); }
-	SField::ref getIFieldSType(int index) { return getFieldSType(index); }
-	std::string getIFieldString(SField::ref field) const { return getFieldString(field); }
-	unsigned char getIFieldU8(SField::ref field) const { return getValueFieldU8(field); }
-	uint16 getIFieldU16(SField::ref field) const { return getValueFieldU16(field); }
-	uint32 getIFieldU32(SField::ref field) const { return getValueFieldU32(field); }
-	uint64 getIFieldU64(SField::ref field) const { return getValueFieldU64(field); }
-	uint128 getIFieldH128(SField::ref field) const { return getValueFieldH128(field); }
-	uint160 getIFieldH160(SField::ref field) const { return getValueFieldH160(field); }
-	uint256 getIFieldH256(SField::ref field) const { return getValueFieldH256(field); }
-	std::vector<unsigned char> getIFieldVL(SField::ref field) const { return getValueFieldVL(field); }
-	std::vector<TaggedListItem> getIFieldTL(SField::ref field) const { return getValueFieldTL(field); }
-	NewcoinAddress getIValueFieldAccount(SField::ref field) const { return getValueFieldAccount(field); }
-	STAmount getIValueFieldAmount(SField::ref field) const { return getValueFieldAmount(field); }
-	STVector256 getIFieldV256(SField::ref field) { return getValueFieldV256(field); }
-	void setIFieldU8(SField::ref field, unsigned char v) { return setValueFieldU8(field, v); }
-	void setIFieldU16(SField::ref field, uint16 v) { return setValueFieldU16(field, v); }
-	void setIFieldU32(SField::ref field, uint32 v) { return setValueFieldU32(field, v); }
-	void setIFieldU64(SField::ref field, uint64 v) { return setValueFieldU64(field, v); }
-	void setIFieldH128(SField::ref field, const uint128& v) { return setValueFieldH128(field, v); }
-	void setIFieldH160(SField::ref field, const uint160& v) { return setValueFieldH160(field, v); }
-	void setIFieldH256(SField::ref field, const uint256& v) { return setValueFieldH256(field, v); }
-	void setIFieldVL(SField::ref field, const std::vector<unsigned char>& v)
-		{ return setValueFieldVL(field, v); }
-	void setIFieldTL(SField::ref field, const std::vector<TaggedListItem>& v)
-		{ return setValueFieldTL(field, v); }
-	void setIFieldAccount(SField::ref field, const uint160& account)
-		{ return setValueFieldAccount(field, account); }
-	void setIFieldAccount(SField::ref field, const NewcoinAddress& account)
-		{ return setValueFieldAccount(field, account); }
-	void setIFieldAmount(SField::ref field, const STAmount& amount)
-		{ return setValueFieldAmount(field, amount); }
-	void setIFieldV256(SField::ref field, const STVector256& v) { return setValueFieldV256(field, v); }
-	bool getIFieldPresent(SField::ref field) const { return isFieldPresent(field); }
-	void makeIFieldPresent(SField::ref field) { makeFieldPresent(field); }
-	void makeIFieldAbsent(SField::ref field) { return makeFieldAbsent(field); }
-	// CAUTION: All the above functions are obsolete
-
 };

 typedef SerializedLedgerEntry SLE;
--- a/src/SerializedObject.cpp
+++ b/src/SerializedObject.cpp
@@ -545,6 +545,28 @@ NewcoinAddress STObject::getValueFieldAccount(SField::ref field) const
 	return cf->getValueNCA();
 }

+uint160 STObject::getValueFieldAccount160(SField::ref field) const
+{
+	uint160 a;
+	const SerializedType* rf = peekAtPField(field);
+	if (!rf)
+	{
+#ifdef DEBUG
+		std::cerr << "Account field not found" << std::endl;
+		std::cerr << getFullText() << std::endl;
+#endif
+		throw std::runtime_error("Field not found");
+	}
+	SerializedTypeID id = rf->getSType();
+	if (id != STI_NOTPRESENT)
+	{
+		const STAccount* cf = dynamic_cast<const STAccount *>(rf);
+		if (!cf) throw std::runtime_error("Wrong field type");
+		cf->getValueH160(a);
+	}
+	return a;
+}
+
 std::vector<unsigned char> STObject::getValueFieldVL(SField::ref field) const
 {
 	const SerializedType* rf = peekAtPField(field);
--- a/src/SerializedObject.h
+++ b/src/SerializedObject.h
@@ -103,6 +103,7 @@ public:
 	uint160 getValueFieldH160(SField::ref field) const;
 	uint256 getValueFieldH256(SField::ref field) const;
 	NewcoinAddress getValueFieldAccount(SField::ref field) const;
+	uint160 getValueFieldAccount160(SField::ref field) const;
 	std::vector<unsigned char> getValueFieldVL(SField::ref field) const;
 	std::vector<TaggedListItem> getValueFieldTL(SField::ref field) const;
 	STAmount getValueFieldAmount(SField::ref field) const;
--- a/src/SerializedTransaction.cpp
+++ b/src/SerializedTransaction.cpp
@@ -131,15 +131,6 @@ void SerializedTransaction::setSourceAccount(const NewcoinAddress& naSource)
 	setValueFieldAccount(sfAccount, naSource);
 }

-uint160 SerializedTransaction::getITFieldAccount(SField::ref field) const
-{
-	uint160 r;
-	const STAccount* ac = dynamic_cast<const STAccount*>(peekAtPField(field));
-	if (ac)
-		ac->getValueH160(r);
-	return r;
-}
-
 Json::Value SerializedTransaction::getJson(int options) const
 {
 	Json::Value ret = STObject::getJson(0);
--- a/src/SerializedTransaction.h
+++ b/src/SerializedTransaction.h
@@ -55,51 +55,6 @@ public:
 	uint32 getSequence() const		{ return getValueFieldU32(sfSequence); }
 	void setSequence(uint32 seq)	{ return setValueFieldU32(sfSequence, seq); }

-	// inner transaction field functions (OBSOLETE - use STObject functions)
-	int getITFieldIndex(SField::ref field) const				{ return getFieldIndex(field); }
-	const SerializedType& peekITField(SField::ref field) const	{ return peekAtField(field); } 
-	SerializedType& getITField(SField::ref field)				{ return getField(field); }
-
-	// inner transaction field value functions (OBSOLETE - use STObject functions)
-	std::string getITFieldString(SField::ref field) const { return getFieldString(field); }
-	unsigned char getITFieldU8(SField::ref field) const { return getValueFieldU8(field); }
-	uint16 getITFieldU16(SField::ref field) const { return getValueFieldU16(field); }
-	uint32 getITFieldU32(SField::ref field) const { return getValueFieldU32(field); }
-	uint64 getITFieldU64(SField::ref field) const { return getValueFieldU64(field); }
-	uint128 getITFieldH128(SField::ref field) const { return getValueFieldH128(field); }
-	uint160 getITFieldH160(SField::ref field) const { return getValueFieldH160(field); }
-	uint160 getITFieldAccount(SField::ref field) const;
-	uint256 getITFieldH256(SField::ref field) const { return getValueFieldH256(field); }
-	std::vector<unsigned char> getITFieldVL(SField::ref field) const { return getValueFieldVL(field); }
-	std::vector<TaggedListItem> getITFieldTL(SField::ref field) const { return getValueFieldTL(field); }
-	STAmount getITFieldAmount(SField::ref field) const { return getValueFieldAmount(field); }
-	STPathSet getITFieldPathSet(SField::ref field) const { return getValueFieldPathSet(field); }
-
-	void setITFieldU8(SField::ref field, unsigned char v) { return setValueFieldU8(field, v); }
-	void setITFieldU16(SField::ref field, uint16 v) { return setValueFieldU16(field, v); }
-	void setITFieldU32(SField::ref field, uint32 v) { return setValueFieldU32(field, v); }
-	void setITFieldU64(SField::ref field, uint32 v) { return setValueFieldU64(field, v); }
-	void setITFieldH128(SField::ref field, const uint128& v) { return setValueFieldH128(field, v); }
-	void setITFieldH160(SField::ref field, const uint160& v) { return setValueFieldH160(field, v); }
-	void setITFieldH256(SField::ref field, const uint256& v) { return setValueFieldH256(field, v); }
-	void setITFieldVL(SField::ref field, const std::vector<unsigned char>& v)
-		{ return setValueFieldVL(field, v); }
-	void setITFieldTL(SField::ref field, const std::vector<TaggedListItem>& v)
-		{ return setValueFieldTL(field, v); }
-	void setITFieldAccount(SField::ref field, const uint160& v)
-		{ return setValueFieldAccount(field, v); }
-	void setITFieldAccount(SField::ref field, const NewcoinAddress& v)
-		{ return setValueFieldAccount(field, v); }
-	void setITFieldAmount(SField::ref field, const STAmount& v)
-		{ return setValueFieldAmount(field, v); }
-	void setITFieldPathSet(SField::ref field, const STPathSet& v)
-		{ return setValueFieldPathSet(field, v); }
-
-	// optional field functions (OBSOLETE - use STObject functions)
-	bool getITFieldPresent(SField::ref field) const	{ return isFieldPresent(field); }
-	void makeITFieldPresent(SField::ref field)		{ makeFieldPresent(field); }
-	void makeITFieldAbsent(SField::ref field)		{ makeFieldAbsent(field); }
-
 	std::vector<NewcoinAddress> getAffectedAccounts() const;

 	uint256 getTransactionID() const;
--- a/src/Transaction.cpp
+++ b/src/Transaction.cpp
@@ -78,8 +78,8 @@ Transaction::Transaction(

 	if (uSourceTag)
 	{
-		mTransaction->makeITFieldPresent(sfSourceTag);
-		mTransaction->setITFieldU32(sfSourceTag, uSourceTag);
+		mTransaction->makeFieldPresent(sfSourceTag);
+		mTransaction->setValueFieldU32(sfSourceTag, uSourceTag);
 	}
 }

@@ -127,24 +127,24 @@ Transaction::pointer Transaction::setAccountSet(
 	)
 {
 	if (!bEmailHash)
-		mTransaction->setITFieldH128(sfEmailHash, uEmailHash);
+		mTransaction->setValueFieldH128(sfEmailHash, uEmailHash);

 	if (!bWalletLocator)
-		mTransaction->setITFieldH256(sfWalletLocator, uWalletLocator);
+		mTransaction->setValueFieldH256(sfWalletLocator, uWalletLocator);

 	if (naMessagePublic.isValid())
-		mTransaction->setITFieldVL(sfMessageKey, naMessagePublic.getAccountPublic());
+		mTransaction->setValueFieldVL(sfMessageKey, naMessagePublic.getAccountPublic());

 	if (bDomain)
-		mTransaction->setITFieldVL(sfDomain, vucDomain);
+		mTransaction->setValueFieldVL(sfDomain, vucDomain);

 	if (bTransferRate)
-		mTransaction->setITFieldU32(sfTransferRate, uTransferRate);
+		mTransaction->setValueFieldU32(sfTransferRate, uTransferRate);

 	if (bPublish)
 	{
-		mTransaction->setITFieldH256(sfPublishHash, uPublishHash);
-		mTransaction->setITFieldU32(sfPublishSize, uPublishSize);
+		mTransaction->setValueFieldH256(sfPublishHash, uPublishHash);
+		mTransaction->setValueFieldU32(sfPublishSize, uPublishSize);
 	}

 	sign(naPrivateKey);
@@ -188,9 +188,9 @@ Transaction::pointer Transaction::setClaim(
 	const std::vector<unsigned char>& vucPubKey,
 	const std::vector<unsigned char>& vucSignature)
 {
-	mTransaction->setITFieldVL(sfGenerator, vucGenerator);
-	mTransaction->setITFieldVL(sfPublicKey, vucPubKey);
-	mTransaction->setITFieldVL(sfSignature, vucSignature);
+	mTransaction->setValueFieldVL(sfGenerator, vucGenerator);
+	mTransaction->setValueFieldVL(sfPublicKey, vucPubKey);
+	mTransaction->setValueFieldVL(sfSignature, vucSignature);

 	sign(naPrivateKey);

@@ -222,9 +222,9 @@ Transaction::pointer Transaction::setCreate(
 	const NewcoinAddress&	naCreateAccountID,
 	const STAmount&			saFund)
 {
-	mTransaction->setITFieldU32(sfFlags, tfCreateAccount);
-	mTransaction->setITFieldAccount(sfDestination, naCreateAccountID);
-	mTransaction->setITFieldAmount(sfAmount, saFund);
+	mTransaction->setValueFieldU32(sfFlags, tfCreateAccount);
+	mTransaction->setValueFieldAccount(sfDestination, naCreateAccountID);
+	mTransaction->setValueFieldAmount(sfAmount, saFund);

 	sign(naPrivateKey);

@@ -257,13 +257,13 @@ Transaction::pointer Transaction::setCreditSet(
 	bool					bQualityOut,
 	uint32					uQualityOut)
 {
-	mTransaction->setITFieldAmount(sfLimitAmount, saLimitAmount);
+	mTransaction->setValueFieldAmount(sfLimitAmount, saLimitAmount);

 	if (bQualityIn)
-		mTransaction->setITFieldU32(sfQualityIn, uQualityIn);
+		mTransaction->setValueFieldU32(sfQualityIn, uQualityIn);

 	if (bQualityOut)
-		mTransaction->setITFieldU32(sfQualityOut, uQualityOut);
+		mTransaction->setValueFieldU32(sfQualityOut, uQualityOut);

 	sign(naPrivateKey);

@@ -301,14 +301,14 @@ Transaction::pointer Transaction::setNicknameSet(
 	const STAmount&						saMinimumOffer,
 	const std::vector<unsigned char>&	vucSignature)
 {
-	mTransaction->setITFieldH256(sfNickname, uNickname);
+	mTransaction->setValueFieldH256(sfNickname, uNickname);

 	// XXX Make sure field is present even for 0!
 	if (bSetOffer)
-		mTransaction->setITFieldAmount(sfMinimumOffer, saMinimumOffer);
+		mTransaction->setValueFieldAmount(sfMinimumOffer, saMinimumOffer);

 	if (!vucSignature.empty())
-		mTransaction->setITFieldVL(sfSignature, vucSignature);
+		mTransaction->setValueFieldVL(sfSignature, vucSignature);

 	sign(naPrivateKey);

@@ -345,13 +345,13 @@ Transaction::pointer Transaction::setOfferCreate(
 	uint32								uExpiration)
 {
 	if (bPassive)
-		mTransaction->setITFieldU32(sfFlags, tfPassive);
+		mTransaction->setValueFieldU32(sfFlags, tfPassive);

-	mTransaction->setITFieldAmount(sfTakerPays, saTakerPays);
-	mTransaction->setITFieldAmount(sfTakerGets, saTakerGets);
+	mTransaction->setValueFieldAmount(sfTakerPays, saTakerPays);
+	mTransaction->setValueFieldAmount(sfTakerGets, saTakerGets);

 	if (uExpiration)
-		mTransaction->setITFieldU32(sfExpiration, uExpiration);
+		mTransaction->setValueFieldU32(sfExpiration, uExpiration);

 	sign(naPrivateKey);

@@ -382,7 +382,7 @@ Transaction::pointer Transaction::setOfferCancel(
 	const NewcoinAddress&				naPrivateKey,
 	uint32								uSequence)
 {
-	mTransaction->setITFieldU32(sfOfferSequence, uSequence);
+	mTransaction->setValueFieldU32(sfOfferSequence, uSequence);

 	sign(naPrivateKey);

@@ -410,7 +410,7 @@ Transaction::pointer Transaction::setPasswordFund(
 	const NewcoinAddress&	naPrivateKey,
 	const NewcoinAddress&	naDstAccountID)
 {
-	mTransaction->setITFieldAccount(sfDestination, naDstAccountID);
+	mTransaction->setValueFieldAccount(sfDestination, naDstAccountID);

 	sign(naPrivateKey);

@@ -441,10 +441,10 @@ Transaction::pointer Transaction::setPasswordSet(
 	const std::vector<unsigned char>&	vucPubKey,
 	const std::vector<unsigned char>&	vucSignature)
 {
-	mTransaction->setITFieldAccount(sfAuthorizedKey, naAuthKeyID);
-	mTransaction->setITFieldVL(sfGenerator, vucGenerator);
-	mTransaction->setITFieldVL(sfPublicKey, vucPubKey);
-	mTransaction->setITFieldVL(sfSignature, vucSignature);
+	mTransaction->setValueFieldAccount(sfAuthorizedKey, naAuthKeyID);
+	mTransaction->setValueFieldVL(sfGenerator, vucGenerator);
+	mTransaction->setValueFieldVL(sfPublicKey, vucPubKey);
+	mTransaction->setValueFieldVL(sfSignature, vucSignature);

 	sign(naPrivateKey);

@@ -481,17 +481,17 @@ Transaction::pointer Transaction::setPayment(
 	const bool				bPartial,
 	const bool				bLimit)
 {
-	mTransaction->setITFieldAccount(sfDestination, naDstAccountID);
-	mTransaction->setITFieldAmount(sfAmount, saAmount);
+	mTransaction->setValueFieldAccount(sfDestination, naDstAccountID);
+	mTransaction->setValueFieldAmount(sfAmount, saAmount);

 	if (saAmount != saSendMax || saAmount.getCurrency() != saSendMax.getCurrency())
 	{
-		mTransaction->setITFieldAmount(sfSendMax, saSendMax);
+		mTransaction->setValueFieldAmount(sfSendMax, saSendMax);
 	}

 	if (spsPaths.getPathCount())
 	{
-		mTransaction->setITFieldPathSet(sfPaths, spsPaths);
+		mTransaction->setValueFieldPathSet(sfPaths, spsPaths);
 	}

 	sign(naPrivateKey);
@@ -528,10 +528,10 @@ Transaction::pointer Transaction::setWalletAdd(
 	const NewcoinAddress&				naNewPubKey,
 	const std::vector<unsigned char>&	vucSignature)
 {
-	mTransaction->setITFieldAmount(sfAmount, saAmount);
-	mTransaction->setITFieldAccount(sfAuthorizedKey, naAuthKeyID);
-	mTransaction->setITFieldVL(sfPublicKey, naNewPubKey.getAccountPublic());
-	mTransaction->setITFieldVL(sfSignature, vucSignature);
+	mTransaction->setValueFieldAmount(sfAmount, saAmount);
+	mTransaction->setValueFieldAccount(sfAuthorizedKey, naAuthKeyID);
+	mTransaction->setValueFieldVL(sfPublicKey, naNewPubKey.getAccountPublic());
+	mTransaction->setValueFieldVL(sfSignature, vucSignature);

 	sign(naPrivateKey);

--- a/src/Transaction.h
+++ b/src/Transaction.h
@@ -272,15 +272,15 @@ public:

 	SerializedTransaction::pointer getSTransaction() { return mTransaction; }

-	const uint256& getID() const { return mTransactionID; }
-	const NewcoinAddress& getFromAccount() const { return mAccountFrom; }
-	STAmount getAmount() const { return mTransaction->getITFieldU64(sfAmount); }
-	STAmount getFee() const { return mTransaction->getTransactionFee(); }
-	uint32 getFromAccountSeq() const { return mTransaction->getSequence(); }
-	uint32 getIdent() const { return mTransaction->getITFieldU32(sfSourceTag); }
-	std::vector<unsigned char> getSignature() const { return mTransaction->getSignature(); }
-	uint32 getLedger() const { return mInLedger; }
-	TransStatus getStatus() const { return mStatus; }
+	const uint256& getID() const					{ return mTransactionID; }
+	const NewcoinAddress& getFromAccount() const	{ return mAccountFrom; }
+	STAmount getAmount() const						{ return mTransaction->getValueFieldU64(sfAmount); }
+	STAmount getFee() const							{ return mTransaction->getTransactionFee(); }
+	uint32 getFromAccountSeq() const				{ return mTransaction->getSequence(); }
+	uint32 getIdent() const							{ return mTransaction->getValueFieldU32(sfSourceTag); }
+	std::vector<unsigned char> getSignature() const	{ return mTransaction->getSignature(); }
+	uint32 getLedger() const						{ return mInLedger; }
+	TransStatus getStatus() const					{ return mStatus; }

 	void setStatus(TransStatus status, uint32 ledgerSeq);
 	void setStatus(TransStatus status) { mStatus=status; }
--- a/src/TransactionAction.cpp
+++ b/src/TransactionAction.cpp
@@ -29,9 +29,9 @@ TER	TransactionEngine::setAuthorized(const SerializedTransaction& txn, bool bMus
 	// Otherwise, people could deny access to generators.
 	//

-	std::vector<unsigned char>	vucCipher		= txn.getITFieldVL(sfGenerator);
-	std::vector<unsigned char>	vucPubKey		= txn.getITFieldVL(sfPublicKey);
-	std::vector<unsigned char>	vucSignature	= txn.getITFieldVL(sfSignature);
+	std::vector<unsigned char>	vucCipher		= txn.getValueFieldVL(sfGenerator);
+	std::vector<unsigned char>	vucPubKey		= txn.getValueFieldVL(sfPublicKey);
+	std::vector<unsigned char>	vucSignature	= txn.getValueFieldVL(sfSignature);
 	NewcoinAddress				naAccountPublic	= NewcoinAddress::createAccountPublic(vucPubKey);

 	if (!naAccountPublic.accountPublicVerify(Serializer::getSHA512Half(vucCipher), vucSignature))
@@ -52,7 +52,7 @@ TER	TransactionEngine::setAuthorized(const SerializedTransaction& txn, bool bMus

 		sleGen			= entryCreate(ltGENERATOR_MAP, Ledger::getGeneratorIndex(hGeneratorID));

-		sleGen->setIFieldVL(sfGenerator, vucCipher);
+		sleGen->setValueFieldVL(sfGenerator, vucCipher);
 	}
 	else if (bMustSetGenerator)
 	{
@@ -66,9 +66,9 @@ TER	TransactionEngine::setAuthorized(const SerializedTransaction& txn, bool bMus
 	// Set the public key needed to use the account.
 	uint160				uAuthKeyID		= bMustSetGenerator
 											? hGeneratorID								// Claim
-											: txn.getITFieldAccount(sfAuthorizedKey);	// PasswordSet
+											: txn.getValueFieldAccount160(sfAuthorizedKey);	// PasswordSet

-	mTxnAccount->setIFieldAccount(sfAuthorizedKey, uAuthKeyID);
+	mTxnAccount->setValueFieldAccount(sfAuthorizedKey, uAuthKeyID);

 	return tesSUCCESS;
 }
@@ -81,21 +81,21 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
 	// EmailHash
 	//

-	if (txn.getITFieldPresent(sfEmailHash))
+	if (txn.isFieldPresent(sfEmailHash))
 	{
-		uint128		uHash	= txn.getITFieldH128(sfEmailHash);
+		uint128		uHash	= txn.getValueFieldH128(sfEmailHash);

 		if (!uHash)
 		{
 			Log(lsINFO) << "doAccountSet: unset email hash";

-			mTxnAccount->makeIFieldAbsent(sfEmailHash);
+			mTxnAccount->makeFieldAbsent(sfEmailHash);
 		}
 		else
 		{
 			Log(lsINFO) << "doAccountSet: set email hash";

-			mTxnAccount->setIFieldH128(sfEmailHash, uHash);
+			mTxnAccount->setValueFieldH128(sfEmailHash, uHash);
 		}
 	}

@@ -103,21 +103,21 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
 	// WalletLocator
 	//

-	if (txn.getITFieldPresent(sfWalletLocator))
+	if (txn.isFieldPresent(sfWalletLocator))
 	{
-		uint256		uHash	= txn.getITFieldH256(sfWalletLocator);
+		uint256		uHash	= txn.getValueFieldH256(sfWalletLocator);

 		if (!uHash)
 		{
 			Log(lsINFO) << "doAccountSet: unset wallet locator";

-			mTxnAccount->makeIFieldAbsent(sfEmailHash);
+			mTxnAccount->makeFieldAbsent(sfEmailHash);
 		}
 		else
 		{
 			Log(lsINFO) << "doAccountSet: set wallet locator";

-			mTxnAccount->setIFieldH256(sfWalletLocator, uHash);
+			mTxnAccount->setValueFieldH256(sfWalletLocator, uHash);
 		}
 	}

@@ -125,7 +125,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
 	// MessageKey
 	//

-	if (!txn.getITFieldPresent(sfMessageKey))
+	if (!txn.isFieldPresent(sfMessageKey))
 	{
 		nothing();
 	}
@@ -133,28 +133,28 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
 	{
 		Log(lsINFO) << "doAccountSet: set message key";

-		mTxnAccount->setIFieldVL(sfMessageKey, txn.getITFieldVL(sfMessageKey));
+		mTxnAccount->setValueFieldVL(sfMessageKey, txn.getValueFieldVL(sfMessageKey));
 	}

 	//
 	// Domain
 	//

-	if (txn.getITFieldPresent(sfDomain))
+	if (txn.isFieldPresent(sfDomain))
 	{
-		std::vector<unsigned char>	vucDomain	= txn.getITFieldVL(sfDomain);
+		std::vector<unsigned char>	vucDomain	= txn.getValueFieldVL(sfDomain);

 		if (vucDomain.empty())
 		{
 			Log(lsINFO) << "doAccountSet: unset domain";

-			mTxnAccount->makeIFieldAbsent(sfDomain);
+			mTxnAccount->makeFieldAbsent(sfDomain);
 		}
 		else
 		{
 			Log(lsINFO) << "doAccountSet: set domain";

-			mTxnAccount->setIFieldVL(sfDomain, vucDomain);
+			mTxnAccount->setValueFieldVL(sfDomain, vucDomain);
 		}
 	}

@@ -162,21 +162,21 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
 	// TransferRate
 	//

-	if (txn.getITFieldPresent(sfTransferRate))
+	if (txn.isFieldPresent(sfTransferRate))
 	{
-		uint32		uRate	= txn.getITFieldU32(sfTransferRate);
+		uint32		uRate	= txn.getValueFieldU32(sfTransferRate);

 		if (!uRate || uRate == QUALITY_ONE)
 		{
 			Log(lsINFO) << "doAccountSet: unset transfer rate";

-			mTxnAccount->makeIFieldAbsent(sfTransferRate);
+			mTxnAccount->makeFieldAbsent(sfTransferRate);
 		}
 		else if (uRate > QUALITY_ONE)
 		{
 			Log(lsINFO) << "doAccountSet: set transfer rate";

-			mTxnAccount->setIFieldU32(sfTransferRate, uRate);
+			mTxnAccount->setValueFieldU32(sfTransferRate, uRate);
 		}
 		else
 		{
@@ -190,8 +190,8 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
 	// PublishHash && PublishSize
 	//

-	bool	bPublishHash	= txn.getITFieldPresent(sfPublishHash);
-	bool	bPublishSize	= txn.getITFieldPresent(sfPublishSize);
+	bool	bPublishHash	= txn.isFieldPresent(sfPublishHash);
+	bool	bPublishSize	= txn.isFieldPresent(sfPublishSize);

 	if (bPublishHash ^ bPublishSize)
 	{
@@ -201,22 +201,22 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
 	}
 	else if (bPublishHash && bPublishSize)
 	{
-		uint256		uHash	= txn.getITFieldH256(sfPublishHash);
-		uint32		uSize	= txn.getITFieldU32(sfPublishSize);
+		uint256		uHash	= txn.getValueFieldH256(sfPublishHash);
+		uint32		uSize	= txn.getValueFieldU32(sfPublishSize);

 		if (!uHash)
 		{
 			Log(lsINFO) << "doAccountSet: unset publish";

-			mTxnAccount->makeIFieldAbsent(sfPublishHash);
-			mTxnAccount->makeIFieldAbsent(sfPublishSize);
+			mTxnAccount->makeFieldAbsent(sfPublishHash);
+			mTxnAccount->makeFieldAbsent(sfPublishSize);
 		}
 		else
 		{
 			Log(lsINFO) << "doAccountSet: set publish";

-			mTxnAccount->setIFieldH256(sfPublishHash, uHash);
-			mTxnAccount->setIFieldU32(sfPublishSize, uSize);
+			mTxnAccount->setValueFieldH256(sfPublishHash, uHash);
+			mTxnAccount->setValueFieldU32(sfPublishSize, uSize);
 		}
 	}

@@ -241,11 +241,11 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
 	TER			terResult		= tesSUCCESS;
 	Log(lsINFO) << "doCreditSet>";

-	const STAmount		saLimitAmount	= txn.getITFieldAmount(sfLimitAmount);
-	const bool			bQualityIn		= txn.getITFieldPresent(sfQualityIn);
-	const uint32		uQualityIn		= bQualityIn ? txn.getITFieldU32(sfQualityIn) : 0;
-	const bool			bQualityOut		= txn.getITFieldPresent(sfQualityOut);
-	const uint32		uQualityOut		= bQualityIn ? txn.getITFieldU32(sfQualityOut) : 0;
+	const STAmount		saLimitAmount	= txn.getValueFieldAmount(sfLimitAmount);
+	const bool			bQualityIn		= txn.isFieldPresent(sfQualityIn);
+	const uint32		uQualityIn		= bQualityIn ? txn.getValueFieldU32(sfQualityIn) : 0;
+	const bool			bQualityOut		= txn.isFieldPresent(sfQualityOut);
+	const uint32		uQualityOut		= bQualityIn ? txn.getValueFieldU32(sfQualityOut) : 0;
 	const uint160		uCurrencyID		= saLimitAmount.getCurrency();
 	uint160				uDstAccountID	= saLimitAmount.getIssuer();
 	const bool			bFlipped		= mTxnAccountID > uDstAccountID;		// true, iff current is not lowest.
@@ -285,12 +285,12 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
 		if (!saLimitAmount)
 		{
 			// Zeroing line.
-			uint160		uLowID			= sleRippleState->getIValueFieldAmount(sfLowLimit).getIssuer();
-			uint160		uHighID			= sleRippleState->getIValueFieldAmount(sfHighLimit).getIssuer();
+			uint160		uLowID			= sleRippleState->getValueFieldAmount(sfLowLimit).getIssuer();
+			uint160		uHighID			= sleRippleState->getValueFieldAmount(sfHighLimit).getIssuer();
 			bool		bLow			= uLowID == uSrcAccountID;
 			bool		bHigh			= uLowID == uDstAccountID;
-			bool		bBalanceZero	= !sleRippleState->getIValueFieldAmount(sfBalance);
-			STAmount	saDstLimit		= sleRippleState->getIValueFieldAmount(bSendLow ? sfLowLimit : sfHighLimit);
+			bool		bBalanceZero	= !sleRippleState->getValueFieldAmount(sfBalance);
+			STAmount	saDstLimit		= sleRippleState->getValueFieldAmount(bSendLow ? sfLowLimit : sfHighLimit);
 			bool		bDstLimitZero	= !saDstLimit;

 			assert(bLow || bHigh);
@@ -307,7 +307,7 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)

 		if (!bDelIndex)
 		{
-			sleRippleState->setIFieldAmount(bFlipped ? sfHighLimit: sfLowLimit, saLimitAllow);
+			sleRippleState->setValueFieldAmount(bFlipped ? sfHighLimit: sfLowLimit, saLimitAllow);

 			if (!bQualityIn)
 			{
@@ -315,11 +315,11 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
 			}
 			else if (uQualityIn)
 			{
-				sleRippleState->setIFieldU32(bFlipped ? sfLowQualityIn : sfHighQualityIn, uQualityIn);
+				sleRippleState->setValueFieldU32(bFlipped ? sfLowQualityIn : sfHighQualityIn, uQualityIn);
 			}
 			else
 			{
-				sleRippleState->makeIFieldAbsent(bFlipped ? sfLowQualityIn : sfHighQualityIn);
+				sleRippleState->makeFieldAbsent(bFlipped ? sfLowQualityIn : sfHighQualityIn);
 			}

 			if (!bQualityOut)
@@ -328,11 +328,11 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
 			}
 			else if (uQualityOut)
 			{
-				sleRippleState->setIFieldU32(bFlipped ? sfLowQualityOut : sfHighQualityOut, uQualityOut);
+				sleRippleState->setValueFieldU32(bFlipped ? sfLowQualityOut : sfHighQualityOut, uQualityOut);
 			}
 			else
 			{
-				sleRippleState->makeIFieldAbsent(bFlipped ? sfLowQualityOut : sfHighQualityOut);
+				sleRippleState->makeFieldAbsent(bFlipped ? sfLowQualityOut : sfHighQualityOut);
 			}

 			entryModify(sleRippleState);
@@ -354,14 +354,14 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)

 		Log(lsINFO) << "doCreditSet: Creating ripple line: " << sleRippleState->getIndex().ToString();

-		sleRippleState->setIFieldAmount(sfBalance, STAmount(uCurrencyID, ACCOUNT_ONE));	// Zero balance in currency.
-		sleRippleState->setIFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, saLimitAllow);
-		sleRippleState->setIFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uDstAccountID));
+		sleRippleState->setValueFieldAmount(sfBalance, STAmount(uCurrencyID, ACCOUNT_ONE));	// Zero balance in currency.
+		sleRippleState->setValueFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, saLimitAllow);
+		sleRippleState->setValueFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uDstAccountID));

 		if (uQualityIn)
-			sleRippleState->setIFieldU32(bFlipped ? sfHighQualityIn : sfLowQualityIn, uQualityIn);
+			sleRippleState->setValueFieldU32(bFlipped ? sfHighQualityIn : sfLowQualityIn, uQualityIn);
 		if (uQualityOut)
-			sleRippleState->setIFieldU32(bFlipped ? sfHighQualityOut : sfLowQualityOut, uQualityOut);
+			sleRippleState->setValueFieldU32(bFlipped ? sfHighQualityOut : sfLowQualityOut, uQualityOut);

 		uint64			uSrcRef;							// Ignored, dirs never delete.

@@ -380,24 +380,24 @@ TER TransactionEngine::doNicknameSet(const SerializedTransaction& txn)
 {
 	std::cerr << "doNicknameSet>" << std::endl;

-	const uint256		uNickname		= txn.getITFieldH256(sfNickname);
-	const bool			bMinOffer		= txn.getITFieldPresent(sfMinimumOffer);
-	const STAmount		saMinOffer		= bMinOffer ? txn.getITFieldAmount(sfAmount) : STAmount();
+	const uint256		uNickname		= txn.getValueFieldH256(sfNickname);
+	const bool			bMinOffer		= txn.isFieldPresent(sfMinimumOffer);
+	const STAmount		saMinOffer		= bMinOffer ? txn.getValueFieldAmount(sfAmount) : STAmount();

 	SLE::pointer		sleNickname		= entryCache(ltNICKNAME, uNickname);

 	if (sleNickname)
 	{
 		// Edit old entry.
-		sleNickname->setIFieldAccount(sfAccount, mTxnAccountID);
+		sleNickname->setValueFieldAccount(sfAccount, mTxnAccountID);

 		if (bMinOffer && saMinOffer)
 		{
-			sleNickname->setIFieldAmount(sfMinimumOffer, saMinOffer);
+			sleNickname->setValueFieldAmount(sfMinimumOffer, saMinOffer);
 		}
 		else
 		{
-			sleNickname->makeIFieldAbsent(sfMinimumOffer);
+			sleNickname->makeFieldAbsent(sfMinimumOffer);
 		}

 		entryModify(sleNickname);
@@ -411,10 +411,10 @@ TER TransactionEngine::doNicknameSet(const SerializedTransaction& txn)

 		std::cerr << "doNicknameSet: Creating nickname node: " << sleNickname->getIndex().ToString() << std::endl;

-		sleNickname->setIFieldAccount(sfAccount, mTxnAccountID);
+		sleNickname->setValueFieldAccount(sfAccount, mTxnAccountID);

 		if (bMinOffer && saMinOffer)
-			sleNickname->setIFieldAmount(sfMinimumOffer, saMinOffer);
+			sleNickname->setValueFieldAmount(sfMinimumOffer, saMinOffer);
 	}

 	std::cerr << "doNicknameSet<" << std::endl;
@@ -426,7 +426,7 @@ TER TransactionEngine::doPasswordFund(const SerializedTransaction& txn)
 {
 	std::cerr << "doPasswordFund>" << std::endl;

-	const uint160		uDstAccountID	= txn.getITFieldAccount(sfDestination);
+	const uint160		uDstAccountID	= txn.getValueFieldAccount160(sfDestination);
 	SLE::pointer		sleDst			= mTxnAccountID == uDstAccountID
 											? mTxnAccount
 											: entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID));
@@ -486,11 +486,11 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac
 	const bool		bPartialPayment	= isSetBit(uTxFlags, tfPartialPayment);
 	const bool		bLimitQuality	= isSetBit(uTxFlags, tfLimitQuality);
 	const bool		bNoRippleDirect	= isSetBit(uTxFlags, tfNoRippleDirect);
-	const bool		bPaths			= txn.getITFieldPresent(sfPaths);
-	const bool		bMax			= txn.getITFieldPresent(sfSendMax);
-	const uint160	uDstAccountID	= txn.getITFieldAccount(sfDestination);
-	const STAmount	saDstAmount		= txn.getITFieldAmount(sfAmount);
-	const STAmount	saMaxAmount		= bMax ? txn.getITFieldAmount(sfSendMax) : saDstAmount;
+	const bool		bPaths			= txn.isFieldPresent(sfPaths);
+	const bool		bMax			= txn.isFieldPresent(sfSendMax);
+	const uint160	uDstAccountID	= txn.getValueFieldAccount160(sfDestination);
+	const STAmount	saDstAmount		= txn.getValueFieldAmount(sfAmount);
+	const STAmount	saMaxAmount		= bMax ? txn.getValueFieldAmount(sfSendMax) : saDstAmount;
 	const uint160	uSrcCurrency	= saMaxAmount.getCurrency();
 	const uint160	uDstCurrency	= saDstAmount.getCurrency();

@@ -550,8 +550,8 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac
 		// Create the account.
 		sleDst	= entryCreate(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID));

-		sleDst->setIFieldAccount(sfAccount, uDstAccountID);
-		sleDst->setIFieldU32(sfSequence, 1);
+		sleDst->setValueFieldAccount(sfAccount, uDstAccountID);
+		sleDst->setValueFieldU32(sfSequence, 1);
 	}
 	else
 	{
@@ -566,7 +566,7 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac
 	{
 		// Ripple payment

-		STPathSet	spsPaths = txn.getITFieldPathSet(sfPaths);
+		STPathSet	spsPaths = txn.getValueFieldPathSet(sfPaths);
 		STAmount	saMaxAmountAct;
 		STAmount	saDstAmountAct;

@@ -589,7 +589,7 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac
 	{
 		// Direct XNS payment.

-		STAmount	saSrcXNSBalance	= mTxnAccount->getIValueFieldAmount(sfBalance);
+		STAmount	saSrcXNSBalance	= mTxnAccount->getValueFieldAmount(sfBalance);

 		if (saSrcXNSBalance < saDstAmount)
 		{
@@ -600,8 +600,8 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac
 		}
 		else
 		{
-			mTxnAccount->setIFieldAmount(sfBalance, saSrcXNSBalance - saDstAmount);
-			sleDst->setIFieldAmount(sfBalance, sleDst->getIValueFieldAmount(sfBalance) + saDstAmount);
+			mTxnAccount->setValueFieldAmount(sfBalance, saSrcXNSBalance - saDstAmount);
+			sleDst->setValueFieldAmount(sfBalance, sleDst->getValueFieldAmount(sfBalance) + saDstAmount);

 			terResult	= tesSUCCESS;
 		}
@@ -626,9 +626,9 @@ TER TransactionEngine::doWalletAdd(const SerializedTransaction& txn)
 {
 	std::cerr << "WalletAdd>" << std::endl;

-	const std::vector<unsigned char>	vucPubKey		= txn.getITFieldVL(sfPublicKey);
-	const std::vector<unsigned char>	vucSignature	= txn.getITFieldVL(sfSignature);
-	const uint160						uAuthKeyID		= txn.getITFieldAccount(sfAuthorizedKey);
+	const std::vector<unsigned char>	vucPubKey		= txn.getValueFieldVL(sfPublicKey);
+	const std::vector<unsigned char>	vucSignature	= txn.getValueFieldVL(sfSignature);
+	const uint160						uAuthKeyID		= txn.getValueFieldAccount160(sfAuthorizedKey);
 	const NewcoinAddress				naMasterPubKey	= NewcoinAddress::createAccountPublic(vucPubKey);
 	const uint160						uDstAccountID	= naMasterPubKey.getAccountID();

@@ -648,8 +648,8 @@ TER TransactionEngine::doWalletAdd(const SerializedTransaction& txn)
 		return tefCREATED;
 	}

-	STAmount			saAmount		= txn.getITFieldAmount(sfAmount);
-	STAmount			saSrcBalance	= mTxnAccount->getIValueFieldAmount(sfBalance);
+	STAmount			saAmount		= txn.getValueFieldAmount(sfAmount);
+	STAmount			saSrcBalance	= mTxnAccount->getValueFieldAmount(sfBalance);

 	if (saSrcBalance < saAmount)
 	{
@@ -663,15 +663,15 @@ TER TransactionEngine::doWalletAdd(const SerializedTransaction& txn)
 	}

 	// Deduct initial balance from source account.
-	mTxnAccount->setIFieldAmount(sfBalance, saSrcBalance-saAmount);
+	mTxnAccount->setValueFieldAmount(sfBalance, saSrcBalance-saAmount);

 	// Create the account.
 	sleDst	= entryCreate(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID));

-	sleDst->setIFieldAccount(sfAccount, uDstAccountID);
-	sleDst->setIFieldU32(sfSequence, 1);
-	sleDst->setIFieldAmount(sfBalance, saAmount);
-	sleDst->setIFieldAccount(sfAuthorizedKey, uAuthKeyID);
+	sleDst->setValueFieldAccount(sfAccount, uDstAccountID);
+	sleDst->setValueFieldU32(sfSequence, 1);
+	sleDst->setValueFieldAmount(sfBalance, saAmount);
+	sleDst->setValueFieldAccount(sfAuthorizedKey, uAuthKeyID);

 	std::cerr << "WalletAdd<" << std::endl;

@@ -770,11 +770,11 @@ TER TransactionEngine::takeOffers(

 			Log(lsINFO) << "takeOffers: considering offer : " << sleOffer->getJson(0);

-			const uint160	uOfferOwnerID	= sleOffer->getIValueFieldAccount(sfAccount).getAccountID();
-			STAmount		saOfferPays		= sleOffer->getIValueFieldAmount(sfTakerGets);
-			STAmount		saOfferGets		= sleOffer->getIValueFieldAmount(sfTakerPays);
+			const uint160	uOfferOwnerID	= sleOffer->getValueFieldAccount(sfAccount).getAccountID();
+			STAmount		saOfferPays		= sleOffer->getValueFieldAmount(sfTakerGets);
+			STAmount		saOfferGets		= sleOffer->getValueFieldAmount(sfTakerPays);

-			if (sleOffer->getIFieldPresent(sfExpiration) && sleOffer->getIFieldU32(sfExpiration) <= mLedger->getParentCloseTimeNC())
+			if (sleOffer->isFieldPresent(sfExpiration) && sleOffer->getValueFieldU32(sfExpiration) <= mLedger->getParentCloseTimeNC())
 			{
 				// Offer is expired. Expired offers are considered unfunded. Delete it.
 				Log(lsINFO) << "takeOffers: encountered expired offer";
@@ -849,10 +849,10 @@ TER TransactionEngine::takeOffers(
 					// Adjust offer

 					// Offer owner will pay less.  Subtract what taker just got.
-					sleOffer->setIFieldAmount(sfTakerGets, saOfferPays -= saSubTakerGot);
+					sleOffer->setValueFieldAmount(sfTakerGets, saOfferPays -= saSubTakerGot);

 					// Offer owner will get less.  Subtract what owner just paid.
-					sleOffer->setIFieldAmount(sfTakerPays, saOfferGets -= saSubTakerPaid);
+					sleOffer->setValueFieldAmount(sfTakerPays, saOfferGets -= saSubTakerPaid);

 					entryModify(sleOffer);

@@ -919,8 +919,8 @@ TER TransactionEngine::doOfferCreate(const SerializedTransaction& txn)
 Log(lsWARNING) << "doOfferCreate> " << txn.getJson(0);
 	const uint32			txFlags			= txn.getFlags();
 	const bool				bPassive		= isSetBit(txFlags, tfPassive);
-	STAmount				saTakerPays		= txn.getITFieldAmount(sfTakerPays);
-	STAmount				saTakerGets		= txn.getITFieldAmount(sfTakerGets);
+	STAmount				saTakerPays		= txn.getValueFieldAmount(sfTakerPays);
+	STAmount				saTakerGets		= txn.getValueFieldAmount(sfTakerGets);

 Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGets=%s")
 	% saTakerPays.getFullText()
@@ -928,8 +928,8 @@ Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGe

 	const uint160			uPaysIssuerID	= saTakerPays.getIssuer();
 	const uint160			uGetsIssuerID	= saTakerGets.getIssuer();
-	const uint32			uExpiration		= txn.getITFieldU32(sfExpiration);
-	const bool				bHaveExpiration	= txn.getITFieldPresent(sfExpiration);
+	const uint32			uExpiration		= txn.getValueFieldU32(sfExpiration);
+	const bool				bHaveExpiration	= txn.isFieldPresent(sfExpiration);
 	const uint32			uSequence		= txn.getSequence();

 	const uint256			uLedgerIndex	= Ledger::getOfferIndex(mTxnAccountID, uSequence);
@@ -1090,16 +1090,16 @@ Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGe
 			Log(lsWARNING) << "doOfferCreate: uPaysCurrency=" << saTakerPays.getHumanCurrency();
 			Log(lsWARNING) << "doOfferCreate: uGetsCurrency=" << saTakerGets.getHumanCurrency();

-			sleOffer->setIFieldAccount(sfAccount, mTxnAccountID);
-			sleOffer->setIFieldU32(sfSequence, uSequence);
-			sleOffer->setIFieldH256(sfBookDirectory, uDirectory);
-			sleOffer->setIFieldAmount(sfTakerPays, saTakerPays);
-			sleOffer->setIFieldAmount(sfTakerGets, saTakerGets);
-			sleOffer->setIFieldU64(sfOwnerNode, uOwnerNode);
-			sleOffer->setIFieldU64(sfBookNode, uBookNode);
+			sleOffer->setValueFieldAccount(sfAccount, mTxnAccountID);
+			sleOffer->setValueFieldU32(sfSequence, uSequence);
+			sleOffer->setValueFieldH256(sfBookDirectory, uDirectory);
+			sleOffer->setValueFieldAmount(sfTakerPays, saTakerPays);
+			sleOffer->setValueFieldAmount(sfTakerGets, saTakerGets);
+			sleOffer->setValueFieldU64(sfOwnerNode, uOwnerNode);
+			sleOffer->setValueFieldU64(sfBookNode, uBookNode);

 			if (uExpiration)
-				sleOffer->setIFieldU32(sfExpiration, uExpiration);
+				sleOffer->setValueFieldU32(sfExpiration, uExpiration);

 			if (bPassive)
 				sleOffer->setFlag(lsfPassive);
@@ -1114,7 +1114,7 @@ Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGe
 TER TransactionEngine::doOfferCancel(const SerializedTransaction& txn)
 {
 	TER				terResult;
-	const uint32	uSequence	= txn.getITFieldU32(sfOfferSequence);
+	const uint32	uSequence	= txn.getValueFieldU32(sfOfferSequence);
 	const uint256	uOfferIndex	= Ledger::getOfferIndex(mTxnAccountID, uSequence);
 	SLE::pointer	sleOffer	= entryCache(ltOFFER, uOfferIndex);

@@ -1141,14 +1141,14 @@ TER	TransactionEngine::doContractAdd(const SerializedTransaction& txn)
 {
 	Log(lsWARNING) << "doContractAdd> " << txn.getJson(0);

-	const uint32 expiration		= txn.getITFieldU32(sfExpiration);
-//	const uint32 bondAmount		= txn.getITFieldU32(sfBondAmount);
-//	const uint32 stampEscrow	= txn.getITFieldU32(sfStampEscrow);
-	STAmount rippleEscrow		= txn.getITFieldAmount(sfRippleEscrow);
-	std::vector<unsigned char>	createCode		= txn.getITFieldVL(sfCreateCode);
-	std::vector<unsigned char>	fundCode		= txn.getITFieldVL(sfFundCode);
-	std::vector<unsigned char>	removeCode		= txn.getITFieldVL(sfRemoveCode);
-	std::vector<unsigned char>	expireCode		= txn.getITFieldVL(sfExpireCode);
+	const uint32 expiration		= txn.getValueFieldU32(sfExpiration);
+//	const uint32 bondAmount		= txn.getValueFieldU32(sfBondAmount);
+//	const uint32 stampEscrow	= txn.getValueFieldU32(sfStampEscrow);
+	STAmount rippleEscrow		= txn.getValueFieldAmount(sfRippleEscrow);
+	std::vector<unsigned char>	createCode		= txn.getValueFieldVL(sfCreateCode);
+	std::vector<unsigned char>	fundCode		= txn.getValueFieldVL(sfFundCode);
+	std::vector<unsigned char>	removeCode		= txn.getValueFieldVL(sfRemoveCode);
+	std::vector<unsigned char>	expireCode		= txn.getValueFieldVL(sfExpireCode);

 	// make sure
 	// expiration hasn't passed
--- a/src/TransactionEngine.cpp
+++ b/src/TransactionEngine.cpp
@@ -136,7 +136,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa

 			case ttNICKNAME_SET:
 				{
-					SLE::pointer		sleNickname		= entryCache(ltNICKNAME, txn.getITFieldH256(sfNickname));
+					SLE::pointer		sleNickname		= entryCache(ltNICKNAME, txn.getValueFieldH256(sfNickname));

 					if (!sleNickname)
 						saCost	= theConfig.FEE_NICKNAME_CREATE;
@@ -222,8 +222,8 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
 	}
 	else
 	{
-		saSrcBalance	= mTxnAccount->getIValueFieldAmount(sfBalance);
-		bHaveAuthKey	= mTxnAccount->getIFieldPresent(sfAuthorizedKey);
+		saSrcBalance	= mTxnAccount->getValueFieldAmount(sfBalance);
+		bHaveAuthKey	= mTxnAccount->isFieldPresent(sfAuthorizedKey);
 	}

 	// Check if account claimed.
@@ -279,7 +279,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa

 			default:
 				// Verify the transaction's signing public key is the key authorized for signing.
-				if (bHaveAuthKey && naSigningPubKey.getAccountID() == mTxnAccount->getIValueFieldAccount(sfAuthorizedKey).getAccountID())
+				if (bHaveAuthKey && naSigningPubKey.getAccountID() == mTxnAccount->getValueFieldAccount(sfAuthorizedKey).getAccountID())
 				{
 					// Authorized to continue.
 					nothing();
@@ -322,7 +322,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
 	}
 	else
 	{
-		mTxnAccount->setIFieldAmount(sfBalance, saSrcBalance - saPaid);
+		mTxnAccount->setValueFieldAmount(sfBalance, saSrcBalance - saPaid);
 	}

 	// Validate sequence
@@ -332,7 +332,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
 	}
 	else if (saCost)
 	{
-		uint32 a_seq = mTxnAccount->getIFieldU32(sfSequence);
+		uint32 a_seq = mTxnAccount->getValueFieldU32(sfSequence);

 		Log(lsTRACE) << "Aseq=" << a_seq << ", Tseq=" << t_seq;

@@ -359,7 +359,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
 		}
 		else
 		{
-			mTxnAccount->setIFieldU32(sfSequence, t_seq + 1);
+			mTxnAccount->setValueFieldU32(sfSequence, t_seq + 1);
 		}
 	}
 	else