ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-12-06 17:27:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
Use the correponding STObject functions.
This commit is contained in:
JoelKatz
2012-10-01 15:21:22 -07:00
parent 841a404114
commit 79c35f2689
21 changed files with 289 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/AccountState.cpp
View File

@@ -17,7 +17,7 @@ AccountState::AccountState(const NewcoinAddress& naAccountID) : mAccountID(naAcc
mLedgerEntry = boost::make_shared<SerializedLedgerEntry>(ltACCOUNT_ROOT); mLedgerEntry = boost::make_shared<SerializedLedgerEntry>(ltACCOUNT_ROOT);
mLedgerEntry->setIndex(Ledger::getAccountRootIndex(naAccountID)); mLedgerEntry->setIndex(Ledger::getAccountRootIndex(naAccountID));
mLedgerEntry->setIFieldAccount(sfAccount, naAccountID.getAccountID()); mLedgerEntry->setValueFieldAccount(sfAccount, naAccountID.getAccountID());
mValid = true; mValid = true;
} }
@@ -48,8 +48,8 @@ void AccountState::addJson(Json::Value& val)
if (mValid) if (mValid)
{ {
if (mLedgerEntry->getIFieldPresent(sfEmailHash)) if (mLedgerEntry->isFieldPresent(sfEmailHash))
val["UrlGravatar"] = createGravatarUrl(mLedgerEntry->getIFieldH128(sfEmailHash)); val["UrlGravatar"] = createGravatarUrl(mLedgerEntry->getValueFieldH128(sfEmailHash));
} }
else else
{ {

8
src/AccountState.h
View File

@@ -33,16 +33,16 @@ public:
bool bHaveAuthorizedKey() bool bHaveAuthorizedKey()
{ {
return mLedgerEntry->getIFieldPresent(sfAuthorizedKey); return mLedgerEntry->isFieldPresent(sfAuthorizedKey);
} }
NewcoinAddress getAuthorizedKey() NewcoinAddress getAuthorizedKey()
{ {
return mLedgerEntry->getIValueFieldAccount(sfAuthorizedKey); return mLedgerEntry->getValueFieldAccount(sfAuthorizedKey);
} }
STAmount getBalance() const { return mLedgerEntry->getIValueFieldAmount(sfBalance); } STAmount getBalance() const { return mLedgerEntry->getValueFieldAmount(sfBalance); }
uint32 getSeq() const { return mLedgerEntry->getIFieldU32(sfSequence); } uint32 getSeq() const { return mLedgerEntry->getValueFieldU32(sfSequence); }
SerializedLedgerEntry::pointer getSLE() { return mLedgerEntry; } SerializedLedgerEntry::pointer getSLE() { return mLedgerEntry; }
const SerializedLedgerEntry& peekSLE() const { return *mLedgerEntry; } const SerializedLedgerEntry& peekSLE() const { return *mLedgerEntry; }

4
src/Ledger.cpp
View File

@@ -27,8 +27,8 @@ Ledger::Ledger(const NewcoinAddress& masterID, uint64 startAmount) : mTotCoins(s
{ {
// special case: put coins in root account // special case: put coins in root account
AccountState::pointer startAccount = boost::make_shared<AccountState>(masterID); AccountState::pointer startAccount = boost::make_shared<AccountState>(masterID);
startAccount->peekSLE().setIFieldAmount(sfBalance, startAmount); startAccount->peekSLE().setValueFieldAmount(sfBalance, startAmount);
startAccount->peekSLE().setIFieldU32(sfSequence, 1); startAccount->peekSLE().setValueFieldU32(sfSequence, 1);
writeBack(lepCREATE, startAccount->getSLE()); writeBack(lepCREATE, startAccount->getSLE());
#if 0 #if 0
std::cerr << "Root account:"; std::cerr << "Root account:";

108
src/LedgerEntrySet.cpp
View File

@@ -383,28 +383,28 @@ void LedgerEntrySet::calcRawMeta(Serializer& s)
assert(origNode); assert(origNode);
threadOwners(origNode, mLedger, newMod); threadOwners(origNode, mLedger, newMod);
if (origNode->getIFieldPresent(sfAmount)) if (origNode->isFieldPresent(sfAmount))
{ // node has an amount, covers ripple state nodes { // node has an amount, covers ripple state nodes
STAmount amount = origNode->getIValueFieldAmount(sfAmount); STAmount amount = origNode->getValueFieldAmount(sfAmount);
if (amount.isNonZero()) if (amount.isNonZero())
metaNode.addAmount(TMSPrevBalance, amount); metaNode.addAmount(TMSPrevBalance, amount);
amount = curNode->getIValueFieldAmount(sfAmount); amount = curNode->getValueFieldAmount(sfAmount);
if (amount.isNonZero()) if (amount.isNonZero())
metaNode.addAmount(TMSFinalBalance, amount); metaNode.addAmount(TMSFinalBalance, amount);
if (origNode->getType() == ltRIPPLE_STATE) if (origNode->getType() == ltRIPPLE_STATE)
{ {
metaNode.addAccount(TMSLowID, NewcoinAddress::createAccountID(origNode->getIValueFieldAmount(sfLowLimit).getIssuer())); metaNode.addAccount(TMSLowID, NewcoinAddress::createAccountID(origNode->getValueFieldAmount(sfLowLimit).getIssuer()));
metaNode.addAccount(TMSHighID, NewcoinAddress::createAccountID(origNode->getIValueFieldAmount(sfHighLimit).getIssuer())); metaNode.addAccount(TMSHighID, NewcoinAddress::createAccountID(origNode->getValueFieldAmount(sfHighLimit).getIssuer()));
} }
} }
if (origNode->getType() == ltOFFER) if (origNode->getType() == ltOFFER)
{ // check for non-zero balances { // check for non-zero balances
STAmount amount = origNode->getIValueFieldAmount(sfTakerPays); STAmount amount = origNode->getValueFieldAmount(sfTakerPays);
if (amount.isNonZero()) if (amount.isNonZero())
metaNode.addAmount(TMSFinalTakerPays, amount); metaNode.addAmount(TMSFinalTakerPays, amount);
amount = origNode->getIValueFieldAmount(sfTakerGets); amount = origNode->getValueFieldAmount(sfTakerGets);
if (amount.isNonZero()) if (amount.isNonZero())
metaNode.addAmount(TMSFinalTakerGets, amount); metaNode.addAmount(TMSFinalTakerGets, amount);
} }
@@ -429,20 +429,20 @@ void LedgerEntrySet::calcRawMeta(Serializer& s)
if (nType == TMNModifiedNode) if (nType == TMNModifiedNode)
{ {
assert(origNode); assert(origNode);
if (origNode->getIFieldPresent(sfAmount)) if (origNode->isFieldPresent(sfAmount))
{ // node has an amount, covers account root nodes and ripple nodes { // node has an amount, covers account root nodes and ripple nodes
STAmount amount = origNode->getIValueFieldAmount(sfAmount); STAmount amount = origNode->getValueFieldAmount(sfAmount);
if (amount != curNode->getIValueFieldAmount(sfAmount)) if (amount != curNode->getValueFieldAmount(sfAmount))
metaNode.addAmount(TMSPrevBalance, amount); metaNode.addAmount(TMSPrevBalance, amount);
} }
if (origNode->getType() == ltOFFER) if (origNode->getType() == ltOFFER)
{ {
STAmount amount = origNode->getIValueFieldAmount(sfTakerPays); STAmount amount = origNode->getValueFieldAmount(sfTakerPays);
if (amount != curNode->getIValueFieldAmount(sfTakerPays)) if (amount != curNode->getValueFieldAmount(sfTakerPays))
metaNode.addAmount(TMSPrevTakerPays, amount); metaNode.addAmount(TMSPrevTakerPays, amount);
amount = origNode->getIValueFieldAmount(sfTakerGets); amount = origNode->getValueFieldAmount(sfTakerGets);
if (amount != curNode->getIValueFieldAmount(sfTakerGets)) if (amount != curNode->getValueFieldAmount(sfTakerGets))
metaNode.addAmount(TMSPrevTakerGets, amount); metaNode.addAmount(TMSPrevTakerGets, amount);
} }
@@ -485,7 +485,7 @@ TER LedgerEntrySet::dirAdd(
} }
else else
{ {
uNodeDir = sleRoot->getIFieldU64(sfIndexPrevious); // Get index to last directory node. uNodeDir = sleRoot->getValueFieldU64(sfIndexPrevious); // Get index to last directory node.
if (uNodeDir) if (uNodeDir)
{ {
@@ -500,7 +500,7 @@ TER LedgerEntrySet::dirAdd(
sleNode = sleRoot; sleNode = sleRoot;
} }
svIndexes = sleNode->getIFieldV256(sfIndexes); svIndexes = sleNode->getValueFieldV256(sfIndexes);
if (DIR_NODE_MAX != svIndexes.peekValue().size()) if (DIR_NODE_MAX != svIndexes.peekValue().size())
{ {
@@ -519,7 +519,7 @@ TER LedgerEntrySet::dirAdd(
{ {
// Previous node is root node. // Previous node is root node.
sleRoot->setIFieldU64(sfIndexNext, uNodeDir); sleRoot->setValueFieldU64(sfIndexNext, uNodeDir);
} }
else else
{ {
@@ -527,14 +527,14 @@ TER LedgerEntrySet::dirAdd(
SLE::pointer slePrevious = entryCache(ltDIR_NODE, Ledger::getDirNodeIndex(uRootIndex, uNodeDir-1)); SLE::pointer slePrevious = entryCache(ltDIR_NODE, Ledger::getDirNodeIndex(uRootIndex, uNodeDir-1));
slePrevious->setIFieldU64(sfIndexNext, uNodeDir); slePrevious->setValueFieldU64(sfIndexNext, uNodeDir);
entryModify(slePrevious); entryModify(slePrevious);
sleNode->setIFieldU64(sfIndexPrevious, uNodeDir-1); sleNode->setValueFieldU64(sfIndexPrevious, uNodeDir-1);
} }
// Have root point to new node. // Have root point to new node.
sleRoot->setIFieldU64(sfIndexPrevious, uNodeDir); sleRoot->setValueFieldU64(sfIndexPrevious, uNodeDir);
entryModify(sleRoot); entryModify(sleRoot);
// Create the new node. // Create the new node.
@@ -544,7 +544,7 @@ TER LedgerEntrySet::dirAdd(
} }
svIndexes.peekValue().push_back(uLedgerIndex); // Append entry. 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: creating: root: " << uRootIndex.ToString();
Log(lsINFO) << "dirAdd: appending: Entry: " << uLedgerIndex.ToString(); Log(lsINFO) << "dirAdd: appending: Entry: " << uLedgerIndex.ToString();
@@ -574,7 +574,7 @@ TER LedgerEntrySet::dirDelete(
return tefBAD_LEDGER; return tefBAD_LEDGER;
} }
STVector256 svIndexes = sleNode->getIFieldV256(sfIndexes); STVector256 svIndexes = sleNode->getValueFieldV256(sfIndexes);
std::vector<uint256>& vuiIndexes = svIndexes.peekValue(); std::vector<uint256>& vuiIndexes = svIndexes.peekValue();
std::vector<uint256>::iterator it; std::vector<uint256>::iterator it;
@@ -608,14 +608,14 @@ TER LedgerEntrySet::dirDelete(
vuiIndexes.clear(); vuiIndexes.clear();
} }
sleNode->setIFieldV256(sfIndexes, svIndexes); sleNode->setValueFieldV256(sfIndexes, svIndexes);
entryModify(sleNode); entryModify(sleNode);
if (vuiIndexes.empty()) if (vuiIndexes.empty())
{ {
// May be able to delete nodes. // May be able to delete nodes.
uint64 uNodePrevious = sleNode->getIFieldU64(sfIndexPrevious); uint64 uNodePrevious = sleNode->getValueFieldU64(sfIndexPrevious);
uint64 uNodeNext = sleNode->getIFieldU64(sfIndexNext); uint64 uNodeNext = sleNode->getValueFieldU64(sfIndexNext);
if (!uNodeCur) if (!uNodeCur)
{ {
@@ -646,7 +646,7 @@ TER LedgerEntrySet::dirDelete(
assert(sleLast); assert(sleLast);
if (sleLast->getIFieldV256(sfIndexes).peekValue().empty()) if (sleLast->getValueFieldV256(sfIndexes).peekValue().empty())
{ {
// Both nodes are empty. // Both nodes are empty.
@@ -690,11 +690,11 @@ TER LedgerEntrySet::dirDelete(
} }
// Fix previous to point to its new next. // Fix previous to point to its new next.
slePrevious->setIFieldU64(sfIndexNext, uNodeNext); slePrevious->setValueFieldU64(sfIndexNext, uNodeNext);
entryModify(slePrevious); entryModify(slePrevious);
// Fix next to point to its new previous. // Fix next to point to its new previous.
sleNext->setIFieldU64(sfIndexPrevious, uNodePrevious); sleNext->setValueFieldU64(sfIndexPrevious, uNodePrevious);
entryModify(sleNext); entryModify(sleNext);
} }
// Last node. // Last node.
@@ -712,7 +712,7 @@ TER LedgerEntrySet::dirDelete(
assert(sleRoot); assert(sleRoot);
if (sleRoot->getIFieldV256(sfIndexes).peekValue().empty()) if (sleRoot->getValueFieldV256(sfIndexes).peekValue().empty())
{ {
// Both nodes are empty. // Both nodes are empty.
@@ -755,12 +755,12 @@ bool LedgerEntrySet::dirNext(
unsigned int& uDirEntry, // <-> next entry unsigned int& uDirEntry, // <-> next entry
uint256& uEntryIndex) // <-- The entry, if available. Otherwise, zero. uint256& uEntryIndex) // <-- The entry, if available. Otherwise, zero.
{ {
STVector256 svIndexes = sleNode->getIFieldV256(sfIndexes); STVector256 svIndexes = sleNode->getValueFieldV256(sfIndexes);
std::vector<uint256>& vuiIndexes = svIndexes.peekValue(); std::vector<uint256>& vuiIndexes = svIndexes.peekValue();
if (uDirEntry == vuiIndexes.size()) if (uDirEntry == vuiIndexes.size())
{ {
uint64 uNodeNext = sleNode->getIFieldU64(sfIndexNext); uint64 uNodeNext = sleNode->getValueFieldU64(sfIndexNext);
if (!uNodeNext) 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) 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); TER terResult = dirDelete(false, uOwnerNode, Ledger::getOwnerDirIndex(uOwnerID), uOfferIndex, false);
if (tesSUCCESS == terResult) if (tesSUCCESS == terResult)
{ {
uint256 uDirectory = sleOffer->getIFieldH256(sfBookDirectory); uint256 uDirectory = sleOffer->getValueFieldH256(sfBookDirectory);
uint64 uBookNode = sleOffer->getIFieldU64(sfBookNode); uint64 uBookNode = sleOffer->getValueFieldU64(sfBookNode);
terResult = dirDelete(false, uBookNode, uDirectory, uOfferIndex, true); 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) TER LedgerEntrySet::offerDelete(const uint256& uOfferIndex)
{ {
SLE::pointer sleOffer = entryCache(ltOFFER, 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); return offerDelete(sleOffer, uOfferIndex, uOwnerID);
} }
@@ -818,7 +818,7 @@ STAmount LedgerEntrySet::rippleOwed(const uint160& uToAccountID, const uint160&
if (sleRippleState) if (sleRippleState)
{ {
saBalance = sleRippleState->getIValueFieldAmount(sfBalance); saBalance = sleRippleState->getValueFieldAmount(sfBalance);
if (uToAccountID < uFromAccountID) if (uToAccountID < uFromAccountID)
saBalance.negate(); saBalance.negate();
saBalance.setIssuer(uToAccountID); saBalance.setIssuer(uToAccountID);
@@ -849,7 +849,7 @@ STAmount LedgerEntrySet::rippleLimit(const uint160& uToAccountID, const uint160&
assert(sleRippleState); assert(sleRippleState);
if (sleRippleState) if (sleRippleState)
{ {
saLimit = sleRippleState->getIValueFieldAmount(uToAccountID < uFromAccountID ? sfLowLimit : sfHighLimit); saLimit = sleRippleState->getValueFieldAmount(uToAccountID < uFromAccountID ? sfLowLimit : sfHighLimit);
saLimit.setIssuer(uToAccountID); saLimit.setIssuer(uToAccountID);
} }
@@ -861,8 +861,8 @@ uint32 LedgerEntrySet::rippleTransferRate(const uint160& uIssuerID)
{ {
SLE::pointer sleAccount = entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uIssuerID)); SLE::pointer sleAccount = entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uIssuerID));
uint32 uQuality = sleAccount && sleAccount->getIFieldPresent(sfTransferRate) uint32 uQuality = sleAccount && sleAccount->isFieldPresent(sfTransferRate)
? sleAccount->getIFieldU32(sfTransferRate) ? sleAccount->getValueFieldU32(sfTransferRate)
: QUALITY_ONE; : QUALITY_ONE;
Log(lsINFO) << boost::str(boost::format("rippleTransferRate: uIssuerID=%s account_exists=%d transfer_rate=%f") 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; SField::ref sfField = uToAccountID < uFromAccountID ? sfLow: sfHigh;
uQuality = sleRippleState->getIFieldPresent(sfField) uQuality = sleRippleState->isFieldPresent(sfField)
? sleRippleState->getIFieldU32(sfField) ? sleRippleState->getValueFieldU32(sfField)
: QUALITY_ONE; : QUALITY_ONE;
if (!uQuality) if (!uQuality)
@@ -924,7 +924,7 @@ STAmount LedgerEntrySet::rippleHolds(const uint160& uAccountID, const uint160& u
if (sleRippleState) if (sleRippleState)
{ {
saBalance = sleRippleState->getIValueFieldAmount(sfBalance); saBalance = sleRippleState->getValueFieldAmount(sfBalance);
if (uAccountID > uIssuerID) if (uAccountID > uIssuerID)
saBalance.negate(); // Put balance in uAccountID terms. 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)); SLE::pointer sleAccount = entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uAccountID));
saAmount = sleAccount->getIValueFieldAmount(sfBalance); saAmount = sleAccount->getValueFieldAmount(sfBalance);
} }
else else
{ {
@@ -1031,13 +1031,13 @@ void LedgerEntrySet::rippleCredit(const uint160& uSenderID, const uint160& uRece
if (!bFlipped) if (!bFlipped)
saBalance.negate(); saBalance.negate();
sleRippleState->setIFieldAmount(sfBalance, saBalance); sleRippleState->setValueFieldAmount(sfBalance, saBalance);
sleRippleState->setIFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, STAmount(uCurrencyID, uSenderID)); sleRippleState->setValueFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, STAmount(uCurrencyID, uSenderID));
sleRippleState->setIFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uReceiverID)); sleRippleState->setValueFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uReceiverID));
} }
else else
{ {
STAmount saBalance = sleRippleState->getIValueFieldAmount(sfBalance); STAmount saBalance = sleRippleState->getValueFieldAmount(sfBalance);
if (!bFlipped) if (!bFlipped)
saBalance.negate(); // Put balance in low terms. saBalance.negate(); // Put balance in low terms.
@@ -1047,7 +1047,7 @@ void LedgerEntrySet::rippleCredit(const uint160& uSenderID, const uint160& uRece
if (!bFlipped) if (!bFlipped)
saBalance.negate(); saBalance.negate();
sleRippleState->setIFieldAmount(sfBalance, saBalance); sleRippleState->setValueFieldAmount(sfBalance, saBalance);
entryModify(sleRippleState); 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") Log(lsINFO) << boost::str(boost::format("accountSend> %s (%s) -> %s (%s) : %s")
% NewcoinAddress::createHumanAccountID(uSenderID) % NewcoinAddress::createHumanAccountID(uSenderID)
% (sleSender ? (sleSender->getIValueFieldAmount(sfBalance)).getFullText() : "-") % (sleSender ? (sleSender->getValueFieldAmount(sfBalance)).getFullText() : "-")
% NewcoinAddress::createHumanAccountID(uReceiverID) % NewcoinAddress::createHumanAccountID(uReceiverID)
% (sleReceiver ? (sleReceiver->getIValueFieldAmount(sfBalance)).getFullText() : "-") % (sleReceiver ? (sleReceiver->getValueFieldAmount(sfBalance)).getFullText() : "-")
% saAmount.getFullText()); % saAmount.getFullText());
if (sleSender) if (sleSender)
{ {
sleSender->setIFieldAmount(sfBalance, sleSender->getIValueFieldAmount(sfBalance) - saAmount); sleSender->setValueFieldAmount(sfBalance, sleSender->getValueFieldAmount(sfBalance) - saAmount);
entryModify(sleSender); entryModify(sleSender);
} }
if (sleReceiver) if (sleReceiver)
{ {
sleReceiver->setIFieldAmount(sfBalance, sleReceiver->getIValueFieldAmount(sfBalance) + saAmount); sleReceiver->setValueFieldAmount(sfBalance, sleReceiver->getValueFieldAmount(sfBalance) + saAmount);
entryModify(sleReceiver); entryModify(sleReceiver);
} }
Log(lsINFO) << boost::str(boost::format("accountSend< %s (%s) -> %s (%s) : %s") Log(lsINFO) << boost::str(boost::format("accountSend< %s (%s) -> %s (%s) : %s")
% NewcoinAddress::createHumanAccountID(uSenderID) % NewcoinAddress::createHumanAccountID(uSenderID)
% (sleSender ? (sleSender->getIValueFieldAmount(sfBalance)).getFullText() : "-") % (sleSender ? (sleSender->getValueFieldAmount(sfBalance)).getFullText() : "-")
% NewcoinAddress::createHumanAccountID(uReceiverID) % NewcoinAddress::createHumanAccountID(uReceiverID)
% (sleReceiver ? (sleReceiver->getIValueFieldAmount(sfBalance)).getFullText() : "-") % (sleReceiver ? (sleReceiver->getValueFieldAmount(sfBalance)).getFullText() : "-")
% saAmount.getFullText()); % saAmount.getFullText());
} }
else else

14
src/NetworkOPs.cpp
View File

@@ -245,12 +245,12 @@ STVector256 NetworkOPs::getDirNodeInfo(
{ {
Log(lsDEBUG) << "getDirNodeInfo: node index: " << uNodeIndex.ToString(); Log(lsDEBUG) << "getDirNodeInfo: node index: " << uNodeIndex.ToString();
Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(sleNode->getIFieldU64(sfIndexPrevious)); Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(sleNode->getValueFieldU64(sfIndexPrevious));
Log(lsTRACE) << "getDirNodeInfo: last: " << strHex(sleNode->getIFieldU64(sfIndexNext)); Log(lsTRACE) << "getDirNodeInfo: last: " << strHex(sleNode->getValueFieldU64(sfIndexNext));
uNodePrevious = sleNode->getIFieldU64(sfIndexPrevious); uNodePrevious = sleNode->getValueFieldU64(sfIndexPrevious);
uNodeNext = sleNode->getIFieldU64(sfIndexNext); uNodeNext = sleNode->getValueFieldU64(sfIndexNext);
svIndexes = sleNode->getIFieldV256(sfIndexes); svIndexes = sleNode->getValueFieldV256(sfIndexes);
Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(uNodePrevious); Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(uNodePrevious);
Log(lsTRACE) << "getDirNodeInfo: last: " << strHex(uNodeNext); Log(lsTRACE) << "getDirNodeInfo: last: " << strHex(uNodeNext);
@@ -299,7 +299,7 @@ Json::Value NetworkOPs::getOwnerInfo(Ledger::pointer lpLedger, const NewcoinAddr
do do
{ {
STVector256 svIndexes = sleNode->getIFieldV256(sfIndexes); STVector256 svIndexes = sleNode->getValueFieldV256(sfIndexes);
const std::vector<uint256>& vuiIndexes = svIndexes.peekValue(); const std::vector<uint256>& vuiIndexes = svIndexes.peekValue();
BOOST_FOREACH(const uint256& uDirEntry, vuiIndexes) 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) if (uNodeDir)
{ {
lspNode = lepNONE; lspNode = lepNONE;

8
src/NicknameState.cpp
View File

@@ -8,19 +8,19 @@ NicknameState::NicknameState(SerializedLedgerEntry::pointer ledgerEntry) :
bool NicknameState::haveMinimumOffer() const bool NicknameState::haveMinimumOffer() const
{ {
return mLedgerEntry->getIFieldPresent(sfMinimumOffer); return mLedgerEntry->isFieldPresent(sfMinimumOffer);
} }
STAmount NicknameState::getMinimumOffer() const STAmount NicknameState::getMinimumOffer() const
{ {
return mLedgerEntry->getIFieldPresent(sfMinimumOffer) return mLedgerEntry->isFieldPresent(sfMinimumOffer)
? mLedgerEntry->getIValueFieldAmount(sfMinimumOffer) ? mLedgerEntry->getValueFieldAmount(sfMinimumOffer)
: STAmount(); : STAmount();
} }
NewcoinAddress NicknameState::getAccountID() const NewcoinAddress NicknameState::getAccountID() const
{ {
return mLedgerEntry->getIValueFieldAccount(sfAccount); return mLedgerEntry->getValueFieldAccount(sfAccount);
} }
void NicknameState::addJson(Json::Value& val) void NicknameState::addJson(Json::Value& val)

4
src/OrderBook.cpp
View File

@@ -10,8 +10,8 @@ OrderBook::pointer OrderBook::newOrderBook(SerializedLedgerEntry::pointer ledger
OrderBook::OrderBook(SerializedLedgerEntry::pointer ledgerEntry) OrderBook::OrderBook(SerializedLedgerEntry::pointer ledgerEntry)
{ {
const STAmount saTakerGets = ledgerEntry->getIValueFieldAmount(sfTakerGets); const STAmount saTakerGets = ledgerEntry->getValueFieldAmount(sfTakerGets);
const STAmount saTakerPays = ledgerEntry->getIValueFieldAmount(sfTakerPays); const STAmount saTakerPays = ledgerEntry->getValueFieldAmount(sfTakerPays);
mCurrencyIn = saTakerGets.getCurrency(); mCurrencyIn = saTakerGets.getCurrency();
mCurrencyOut = saTakerPays.getCurrency(); mCurrencyOut = saTakerPays.getCurrency();

4
src/RPCServer.cpp
View File

@@ -252,7 +252,7 @@ Json::Value RPCServer::getMasterGenerator(const uint256& uLedger, const NewcoinA
return RPCError(rpcNO_ACCOUNT); 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); std::vector<unsigned char> vucMasterGenerator = na0Private.accountPrivateDecrypt(na0Public, vucCipher);
if (vucMasterGenerator.empty()) if (vucMasterGenerator.empty())
{ {
@@ -402,7 +402,7 @@ Json::Value RPCServer::accountFromString(const uint256& uLedger, NewcoinAddress&
else else
{ {
// Found master public key. // 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); std::vector<unsigned char> vucMasterGenerator = naRegular0Private.accountPrivateDecrypt(naRegular0Public, vucCipher);
if (vucMasterGenerator.empty()) if (vucMasterGenerator.empty())
{ {

28
src/RippleCalc.cpp
View File

@@ -116,8 +116,8 @@ TER RippleCalc::calcNodeAdvance(
{ {
if (bFundsDirty) if (bFundsDirty)
{ {
saTakerPays = sleOffer->getIValueFieldAmount(sfTakerPays); saTakerPays = sleOffer->getValueFieldAmount(sfTakerPays);
saTakerGets = sleOffer->getIValueFieldAmount(sfTakerGets); saTakerGets = sleOffer->getValueFieldAmount(sfTakerGets);
saOfferFunds = lesActive.accountFunds(uOfrOwnerID, saTakerGets); // Funds left. saOfferFunds = lesActive.accountFunds(uOfrOwnerID, saTakerGets); // Funds left.
bFundsDirty = false; bFundsDirty = false;
@@ -153,13 +153,13 @@ TER RippleCalc::calcNodeAdvance(
{ {
// Got a new offer. // Got a new offer.
sleOffer = lesActive.entryCache(ltOFFER, uOfferIndex); sleOffer = lesActive.entryCache(ltOFFER, uOfferIndex);
uOfrOwnerID = sleOffer->getIValueFieldAccount(sfAccount).getAccountID(); uOfrOwnerID = sleOffer->getValueFieldAccount(sfAccount).getAccountID();
const aciSource asLine = boost::make_tuple(uOfrOwnerID, uCurCurrencyID, uCurIssuerID); const aciSource asLine = boost::make_tuple(uOfrOwnerID, uCurCurrencyID, uCurIssuerID);
Log(lsINFO) << boost::str(boost::format("calcNodeAdvance: uOfrOwnerID=%s") % NewcoinAddress::createHumanAccountID(uOfrOwnerID)); 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. // Offer is expired.
Log(lsINFO) << "calcNodeAdvance: expired offer"; Log(lsINFO) << "calcNodeAdvance: expired offer";
@@ -207,8 +207,8 @@ TER RippleCalc::calcNodeAdvance(
continue; continue;
} }
saTakerPays = sleOffer->getIValueFieldAmount(sfTakerPays); saTakerPays = sleOffer->getValueFieldAmount(sfTakerPays);
saTakerGets = sleOffer->getIValueFieldAmount(sfTakerGets); saTakerGets = sleOffer->getValueFieldAmount(sfTakerGets);
saOfferFunds = lesActive.accountFunds(uOfrOwnerID, saTakerGets); // Funds left. saOfferFunds = lesActive.accountFunds(uOfrOwnerID, saTakerGets); // Funds left.
@@ -430,8 +430,8 @@ TER RippleCalc::calcNodeDeliverRev(
lesActive.accountSend(uOfrOwnerID, uCurIssuerID, saOutPass); lesActive.accountSend(uOfrOwnerID, uCurIssuerID, saOutPass);
// Adjust offer // Adjust offer
sleOffer->setIFieldAmount(sfTakerGets, saTakerGets - saOutPass); sleOffer->setValueFieldAmount(sfTakerGets, saTakerGets - saOutPass);
sleOffer->setIFieldAmount(sfTakerPays, saTakerPays - saInPassAct); sleOffer->setValueFieldAmount(sfTakerPays, saTakerPays - saInPassAct);
lesActive.entryModify(sleOffer); lesActive.entryModify(sleOffer);
@@ -580,8 +580,8 @@ TER RippleCalc::calcNodeDeliverFwd(
lesActive.accountSend(uInAccountID, uOfrOwnerID, saInPassAct); lesActive.accountSend(uInAccountID, uOfrOwnerID, saInPassAct);
// Adjust offer // Adjust offer
sleOffer->setIFieldAmount(sfTakerGets, saTakerGets - saOutPassAct); sleOffer->setValueFieldAmount(sfTakerGets, saTakerGets - saOutPassAct);
sleOffer->setIFieldAmount(sfTakerPays, saTakerPays - saInPassAct); sleOffer->setValueFieldAmount(sfTakerPays, saTakerPays - saInPassAct);
lesActive.entryModify(sleOffer); lesActive.entryModify(sleOffer);
@@ -2092,11 +2092,11 @@ void TransactionEngine::calcOfferBridgeNext(
SLE::pointer sleOffer = entryCache(ltOFFER, uOfferIndex); SLE::pointer sleOffer = entryCache(ltOFFER, uOfferIndex);
uint160 uOfferOwnerID = sleOffer->getIValueFieldAccount(sfAccount).getAccountID(); uint160 uOfferOwnerID = sleOffer->getValueFieldAccount(sfAccount).getAccountID();
STAmount saOfferPays = sleOffer->getIValueFieldAmount(sfTakerGets); STAmount saOfferPays = sleOffer->getValueFieldAmount(sfTakerGets);
STAmount saOfferGets = sleOffer->getIValueFieldAmount(sfTakerPays); 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. // Offer is expired.
Log(lsINFO) << "calcOfferFirst: encountered expired offer"; Log(lsINFO) << "calcOfferFirst: encountered expired offer";

4
src/RippleLines.cpp
View File

@@ -25,7 +25,7 @@ void RippleLines::fillLines(const uint160& accountID, Ledger::pointer ledger)
SLE::pointer rippleDir=ledger->getDirNode(lspNode, currentIndex); SLE::pointer rippleDir=ledger->getDirNode(lspNode, currentIndex);
if (!rippleDir) return; if (!rippleDir) return;
STVector256 svOwnerNodes = rippleDir->getIFieldV256(sfIndexes); STVector256 svOwnerNodes = rippleDir->getValueFieldV256(sfIndexes);
BOOST_FOREACH(uint256& uNode, svOwnerNodes.peekValue()) BOOST_FOREACH(uint256& uNode, svOwnerNodes.peekValue())
{ {
SLE::pointer sleCur = ledger->getSLE(uNode); 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; if (!uNodeNext) return;
currentIndex = Ledger::getDirNodeIndex(rootIndex, uNodeNext); currentIndex = Ledger::getDirNodeIndex(rootIndex, uNodeNext);

14
src/RippleState.cpp
View File

@@ -7,19 +7,19 @@ RippleState::RippleState(SerializedLedgerEntry::pointer ledgerEntry) :
{ {
if (!mLedgerEntry || mLedgerEntry->getType() != ltRIPPLE_STATE) return; if (!mLedgerEntry || mLedgerEntry->getType() != ltRIPPLE_STATE) return;
mLowLimit = mLedgerEntry->getIValueFieldAmount(sfLowLimit); mLowLimit = mLedgerEntry->getValueFieldAmount(sfLowLimit);
mHighLimit = mLedgerEntry->getIValueFieldAmount(sfHighLimit); mHighLimit = mLedgerEntry->getValueFieldAmount(sfHighLimit);
mLowID = NewcoinAddress::createAccountID(mLowLimit.getIssuer()); mLowID = NewcoinAddress::createAccountID(mLowLimit.getIssuer());
mHighID = NewcoinAddress::createAccountID(mHighLimit.getIssuer()); mHighID = NewcoinAddress::createAccountID(mHighLimit.getIssuer());
mLowQualityIn = mLedgerEntry->getIFieldU32(sfLowQualityIn); mLowQualityIn = mLedgerEntry->getValueFieldU32(sfLowQualityIn);
mLowQualityOut = mLedgerEntry->getIFieldU32(sfLowQualityOut); mLowQualityOut = mLedgerEntry->getValueFieldU32(sfLowQualityOut);
mHighQualityIn = mLedgerEntry->getIFieldU32(sfHighQualityIn); mHighQualityIn = mLedgerEntry->getValueFieldU32(sfHighQualityIn);
mHighQualityOut = mLedgerEntry->getIFieldU32(sfHighQualityOut); mHighQualityOut = mLedgerEntry->getValueFieldU32(sfHighQualityOut);
mBalance = mLedgerEntry->getIValueFieldAmount(sfBalance); mBalance = mLedgerEntry->getValueFieldAmount(sfBalance);
mValid = true; mValid = true;
} }

4
src/SerializedLedger.cpp
View File

@@ -124,12 +124,12 @@ NewcoinAddress SerializedLedgerEntry::getOwner()
NewcoinAddress SerializedLedgerEntry::getFirstOwner() NewcoinAddress SerializedLedgerEntry::getFirstOwner()
{ {
return NewcoinAddress::createAccountID(getIValueFieldAmount(sfLowLimit).getIssuer()); return NewcoinAddress::createAccountID(getValueFieldAmount(sfLowLimit).getIssuer());
} }
NewcoinAddress SerializedLedgerEntry::getSecondOwner() NewcoinAddress SerializedLedgerEntry::getSecondOwner()
{ {
return NewcoinAddress::createAccountID(getIValueFieldAmount(sfHighLimit).getIssuer()); return NewcoinAddress::createAccountID(getValueFieldAmount(sfHighLimit).getIssuer());
} }
std::vector<uint256> SerializedLedgerEntry::getOwners() std::vector<uint256> SerializedLedgerEntry::getOwners()

44
src/SerializedLedger.h
View File

@@ -46,50 +46,6 @@ public:
uint32 getThreadedLedger(); uint32 getThreadedLedger();
bool thread(const uint256& txID, uint32 ledgerSeq, uint256& prevTxID, uint32& prevLedgerID); bool thread(const uint256& txID, uint32 ledgerSeq, uint256& prevTxID, uint32& prevLedgerID);
std::vector<uint256> getOwners(); // nodes notified if this node is deleted 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; typedef SerializedLedgerEntry SLE;

22
src/SerializedObject.cpp
View File

@@ -545,6 +545,28 @@ NewcoinAddress STObject::getValueFieldAccount(SField::ref field) const
return cf->getValueNCA(); 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 std::vector<unsigned char> STObject::getValueFieldVL(SField::ref field) const
{ {
const SerializedType* rf = peekAtPField(field); const SerializedType* rf = peekAtPField(field);

1
src/SerializedObject.h
View File

@@ -103,6 +103,7 @@ public:
uint160 getValueFieldH160(SField::ref field) const; uint160 getValueFieldH160(SField::ref field) const;
uint256 getValueFieldH256(SField::ref field) const; uint256 getValueFieldH256(SField::ref field) const;
NewcoinAddress getValueFieldAccount(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<unsigned char> getValueFieldVL(SField::ref field) const;
std::vector<TaggedListItem> getValueFieldTL(SField::ref field) const; std::vector<TaggedListItem> getValueFieldTL(SField::ref field) const;
STAmount getValueFieldAmount(SField::ref field) const; STAmount getValueFieldAmount(SField::ref field) const;

9
src/SerializedTransaction.cpp
View File

@@ -131,15 +131,6 @@ void SerializedTransaction::setSourceAccount(const NewcoinAddress& naSource)
setValueFieldAccount(sfAccount, 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 SerializedTransaction::getJson(int options) const
{ {
Json::Value ret = STObject::getJson(0); Json::Value ret = STObject::getJson(0);

45
src/SerializedTransaction.h
View File

@@ -55,51 +55,6 @@ public:
uint32 getSequence() const { return getValueFieldU32(sfSequence); } uint32 getSequence() const { return getValueFieldU32(sfSequence); }
void setSequence(uint32 seq) { return setValueFieldU32(sfSequence, seq); } 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; std::vector<NewcoinAddress> getAffectedAccounts() const;
uint256 getTransactionID() const; uint256 getTransactionID() const;

78
src/Transaction.cpp
View File

@@ -78,8 +78,8 @@ Transaction::Transaction(
if (uSourceTag) if (uSourceTag)
{ {
mTransaction->makeITFieldPresent(sfSourceTag); mTransaction->makeFieldPresent(sfSourceTag);
mTransaction->setITFieldU32(sfSourceTag, uSourceTag); mTransaction->setValueFieldU32(sfSourceTag, uSourceTag);
} }
} }
@@ -127,24 +127,24 @@ Transaction::pointer Transaction::setAccountSet(
) )
{ {
if (!bEmailHash) if (!bEmailHash)
mTransaction->setITFieldH128(sfEmailHash, uEmailHash); mTransaction->setValueFieldH128(sfEmailHash, uEmailHash);
if (!bWalletLocator) if (!bWalletLocator)
mTransaction->setITFieldH256(sfWalletLocator, uWalletLocator); mTransaction->setValueFieldH256(sfWalletLocator, uWalletLocator);
if (naMessagePublic.isValid()) if (naMessagePublic.isValid())
mTransaction->setITFieldVL(sfMessageKey, naMessagePublic.getAccountPublic()); mTransaction->setValueFieldVL(sfMessageKey, naMessagePublic.getAccountPublic());
if (bDomain) if (bDomain)
mTransaction->setITFieldVL(sfDomain, vucDomain); mTransaction->setValueFieldVL(sfDomain, vucDomain);
if (bTransferRate) if (bTransferRate)
mTransaction->setITFieldU32(sfTransferRate, uTransferRate); mTransaction->setValueFieldU32(sfTransferRate, uTransferRate);
if (bPublish) if (bPublish)
{ {
mTransaction->setITFieldH256(sfPublishHash, uPublishHash); mTransaction->setValueFieldH256(sfPublishHash, uPublishHash);
mTransaction->setITFieldU32(sfPublishSize, uPublishSize); mTransaction->setValueFieldU32(sfPublishSize, uPublishSize);
} }
sign(naPrivateKey); sign(naPrivateKey);
@@ -188,9 +188,9 @@ Transaction::pointer Transaction::setClaim(
const std::vector<unsigned char>& vucPubKey, const std::vector<unsigned char>& vucPubKey,
const std::vector<unsigned char>& vucSignature) const std::vector<unsigned char>& vucSignature)
{ {
mTransaction->setITFieldVL(sfGenerator, vucGenerator); mTransaction->setValueFieldVL(sfGenerator, vucGenerator);
mTransaction->setITFieldVL(sfPublicKey, vucPubKey); mTransaction->setValueFieldVL(sfPublicKey, vucPubKey);
mTransaction->setITFieldVL(sfSignature, vucSignature); mTransaction->setValueFieldVL(sfSignature, vucSignature);
sign(naPrivateKey); sign(naPrivateKey);
@@ -222,9 +222,9 @@ Transaction::pointer Transaction::setCreate(
const NewcoinAddress& naCreateAccountID, const NewcoinAddress& naCreateAccountID,
const STAmount& saFund) const STAmount& saFund)
{ {
mTransaction->setITFieldU32(sfFlags, tfCreateAccount); mTransaction->setValueFieldU32(sfFlags, tfCreateAccount);
mTransaction->setITFieldAccount(sfDestination, naCreateAccountID); mTransaction->setValueFieldAccount(sfDestination, naCreateAccountID);
mTransaction->setITFieldAmount(sfAmount, saFund); mTransaction->setValueFieldAmount(sfAmount, saFund);
sign(naPrivateKey); sign(naPrivateKey);
@@ -257,13 +257,13 @@ Transaction::pointer Transaction::setCreditSet(
bool bQualityOut, bool bQualityOut,
uint32 uQualityOut) uint32 uQualityOut)
{ {
mTransaction->setITFieldAmount(sfLimitAmount, saLimitAmount); mTransaction->setValueFieldAmount(sfLimitAmount, saLimitAmount);
if (bQualityIn) if (bQualityIn)
mTransaction->setITFieldU32(sfQualityIn, uQualityIn); mTransaction->setValueFieldU32(sfQualityIn, uQualityIn);
if (bQualityOut) if (bQualityOut)
mTransaction->setITFieldU32(sfQualityOut, uQualityOut); mTransaction->setValueFieldU32(sfQualityOut, uQualityOut);
sign(naPrivateKey); sign(naPrivateKey);
@@ -301,14 +301,14 @@ Transaction::pointer Transaction::setNicknameSet(
const STAmount& saMinimumOffer, const STAmount& saMinimumOffer,
const std::vector<unsigned char>& vucSignature) const std::vector<unsigned char>& vucSignature)
{ {
mTransaction->setITFieldH256(sfNickname, uNickname); mTransaction->setValueFieldH256(sfNickname, uNickname);
// XXX Make sure field is present even for 0! // XXX Make sure field is present even for 0!
if (bSetOffer) if (bSetOffer)
mTransaction->setITFieldAmount(sfMinimumOffer, saMinimumOffer); mTransaction->setValueFieldAmount(sfMinimumOffer, saMinimumOffer);
if (!vucSignature.empty()) if (!vucSignature.empty())
mTransaction->setITFieldVL(sfSignature, vucSignature); mTransaction->setValueFieldVL(sfSignature, vucSignature);
sign(naPrivateKey); sign(naPrivateKey);
@@ -345,13 +345,13 @@ Transaction::pointer Transaction::setOfferCreate(
uint32 uExpiration) uint32 uExpiration)
{ {
if (bPassive) if (bPassive)
mTransaction->setITFieldU32(sfFlags, tfPassive); mTransaction->setValueFieldU32(sfFlags, tfPassive);
mTransaction->setITFieldAmount(sfTakerPays, saTakerPays); mTransaction->setValueFieldAmount(sfTakerPays, saTakerPays);
mTransaction->setITFieldAmount(sfTakerGets, saTakerGets); mTransaction->setValueFieldAmount(sfTakerGets, saTakerGets);
if (uExpiration) if (uExpiration)
mTransaction->setITFieldU32(sfExpiration, uExpiration); mTransaction->setValueFieldU32(sfExpiration, uExpiration);
sign(naPrivateKey); sign(naPrivateKey);
@@ -382,7 +382,7 @@ Transaction::pointer Transaction::setOfferCancel(
const NewcoinAddress& naPrivateKey, const NewcoinAddress& naPrivateKey,
uint32 uSequence) uint32 uSequence)
{ {
mTransaction->setITFieldU32(sfOfferSequence, uSequence); mTransaction->setValueFieldU32(sfOfferSequence, uSequence);
sign(naPrivateKey); sign(naPrivateKey);
@@ -410,7 +410,7 @@ Transaction::pointer Transaction::setPasswordFund(
const NewcoinAddress& naPrivateKey, const NewcoinAddress& naPrivateKey,
const NewcoinAddress& naDstAccountID) const NewcoinAddress& naDstAccountID)
{ {
mTransaction->setITFieldAccount(sfDestination, naDstAccountID); mTransaction->setValueFieldAccount(sfDestination, naDstAccountID);
sign(naPrivateKey); sign(naPrivateKey);
@@ -441,10 +441,10 @@ Transaction::pointer Transaction::setPasswordSet(
const std::vector<unsigned char>& vucPubKey, const std::vector<unsigned char>& vucPubKey,
const std::vector<unsigned char>& vucSignature) const std::vector<unsigned char>& vucSignature)
{ {
mTransaction->setITFieldAccount(sfAuthorizedKey, naAuthKeyID); mTransaction->setValueFieldAccount(sfAuthorizedKey, naAuthKeyID);
mTransaction->setITFieldVL(sfGenerator, vucGenerator); mTransaction->setValueFieldVL(sfGenerator, vucGenerator);
mTransaction->setITFieldVL(sfPublicKey, vucPubKey); mTransaction->setValueFieldVL(sfPublicKey, vucPubKey);
mTransaction->setITFieldVL(sfSignature, vucSignature); mTransaction->setValueFieldVL(sfSignature, vucSignature);
sign(naPrivateKey); sign(naPrivateKey);
@@ -481,17 +481,17 @@ Transaction::pointer Transaction::setPayment(
const bool bPartial, const bool bPartial,
const bool bLimit) const bool bLimit)
{ {
mTransaction->setITFieldAccount(sfDestination, naDstAccountID); mTransaction->setValueFieldAccount(sfDestination, naDstAccountID);
mTransaction->setITFieldAmount(sfAmount, saAmount); mTransaction->setValueFieldAmount(sfAmount, saAmount);
if (saAmount != saSendMax || saAmount.getCurrency() != saSendMax.getCurrency()) if (saAmount != saSendMax || saAmount.getCurrency() != saSendMax.getCurrency())
{ {
mTransaction->setITFieldAmount(sfSendMax, saSendMax); mTransaction->setValueFieldAmount(sfSendMax, saSendMax);
} }
if (spsPaths.getPathCount()) if (spsPaths.getPathCount())
{ {
mTransaction->setITFieldPathSet(sfPaths, spsPaths); mTransaction->setValueFieldPathSet(sfPaths, spsPaths);
} }
sign(naPrivateKey); sign(naPrivateKey);
@@ -528,10 +528,10 @@ Transaction::pointer Transaction::setWalletAdd(
const NewcoinAddress& naNewPubKey, const NewcoinAddress& naNewPubKey,
const std::vector<unsigned char>& vucSignature) const std::vector<unsigned char>& vucSignature)
{ {
mTransaction->setITFieldAmount(sfAmount, saAmount); mTransaction->setValueFieldAmount(sfAmount, saAmount);
mTransaction->setITFieldAccount(sfAuthorizedKey, naAuthKeyID); mTransaction->setValueFieldAccount(sfAuthorizedKey, naAuthKeyID);
mTransaction->setITFieldVL(sfPublicKey, naNewPubKey.getAccountPublic()); mTransaction->setValueFieldVL(sfPublicKey, naNewPubKey.getAccountPublic());
mTransaction->setITFieldVL(sfSignature, vucSignature); mTransaction->setValueFieldVL(sfSignature, vucSignature);
sign(naPrivateKey); sign(naPrivateKey);

4
src/Transaction.h
View File

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

216
src/TransactionAction.cpp
View File

@@ -29,9 +29,9 @@ TER TransactionEngine::setAuthorized(const SerializedTransaction& txn, bool bMus
// Otherwise, people could deny access to generators. // Otherwise, people could deny access to generators.
// //
std::vector<unsigned char> vucCipher = txn.getITFieldVL(sfGenerator); std::vector<unsigned char> vucCipher = txn.getValueFieldVL(sfGenerator);
std::vector<unsigned char> vucPubKey = txn.getITFieldVL(sfPublicKey); std::vector<unsigned char> vucPubKey = txn.getValueFieldVL(sfPublicKey);
std::vector<unsigned char> vucSignature = txn.getITFieldVL(sfSignature); std::vector<unsigned char> vucSignature = txn.getValueFieldVL(sfSignature);
NewcoinAddress naAccountPublic = NewcoinAddress::createAccountPublic(vucPubKey); NewcoinAddress naAccountPublic = NewcoinAddress::createAccountPublic(vucPubKey);
if (!naAccountPublic.accountPublicVerify(Serializer::getSHA512Half(vucCipher), vucSignature)) 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 = entryCreate(ltGENERATOR_MAP, Ledger::getGeneratorIndex(hGeneratorID));
sleGen->setIFieldVL(sfGenerator, vucCipher); sleGen->setValueFieldVL(sfGenerator, vucCipher);
} }
else if (bMustSetGenerator) else if (bMustSetGenerator)
{ {
@@ -66,9 +66,9 @@ TER TransactionEngine::setAuthorized(const SerializedTransaction& txn, bool bMus
// Set the public key needed to use the account. // Set the public key needed to use the account.
uint160 uAuthKeyID = bMustSetGenerator uint160 uAuthKeyID = bMustSetGenerator
? hGeneratorID // Claim ? hGeneratorID // Claim
: txn.getITFieldAccount(sfAuthorizedKey); // PasswordSet : txn.getValueFieldAccount160(sfAuthorizedKey); // PasswordSet
mTxnAccount->setIFieldAccount(sfAuthorizedKey, uAuthKeyID); mTxnAccount->setValueFieldAccount(sfAuthorizedKey, uAuthKeyID);
return tesSUCCESS; return tesSUCCESS;
} }
@@ -81,21 +81,21 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
// EmailHash // EmailHash
// //
if (txn.getITFieldPresent(sfEmailHash)) if (txn.isFieldPresent(sfEmailHash))
{ {
uint128 uHash = txn.getITFieldH128(sfEmailHash); uint128 uHash = txn.getValueFieldH128(sfEmailHash);
if (!uHash) if (!uHash)
{ {
Log(lsINFO) << "doAccountSet: unset email hash"; Log(lsINFO) << "doAccountSet: unset email hash";
mTxnAccount->makeIFieldAbsent(sfEmailHash); mTxnAccount->makeFieldAbsent(sfEmailHash);
} }
else else
{ {
Log(lsINFO) << "doAccountSet: set email hash"; 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 // WalletLocator
// //
if (txn.getITFieldPresent(sfWalletLocator)) if (txn.isFieldPresent(sfWalletLocator))
{ {
uint256 uHash = txn.getITFieldH256(sfWalletLocator); uint256 uHash = txn.getValueFieldH256(sfWalletLocator);
if (!uHash) if (!uHash)
{ {
Log(lsINFO) << "doAccountSet: unset wallet locator"; Log(lsINFO) << "doAccountSet: unset wallet locator";
mTxnAccount->makeIFieldAbsent(sfEmailHash); mTxnAccount->makeFieldAbsent(sfEmailHash);
} }
else else
{ {
Log(lsINFO) << "doAccountSet: set wallet locator"; 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 // MessageKey
// //
if (!txn.getITFieldPresent(sfMessageKey)) if (!txn.isFieldPresent(sfMessageKey))
{ {
nothing(); nothing();
} }
@@ -133,28 +133,28 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
{ {
Log(lsINFO) << "doAccountSet: set message key"; Log(lsINFO) << "doAccountSet: set message key";
mTxnAccount->setIFieldVL(sfMessageKey, txn.getITFieldVL(sfMessageKey)); mTxnAccount->setValueFieldVL(sfMessageKey, txn.getValueFieldVL(sfMessageKey));
} }
// //
// Domain // 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()) if (vucDomain.empty())
{ {
Log(lsINFO) << "doAccountSet: unset domain"; Log(lsINFO) << "doAccountSet: unset domain";
mTxnAccount->makeIFieldAbsent(sfDomain); mTxnAccount->makeFieldAbsent(sfDomain);
} }
else else
{ {
Log(lsINFO) << "doAccountSet: set domain"; Log(lsINFO) << "doAccountSet: set domain";
mTxnAccount->setIFieldVL(sfDomain, vucDomain); mTxnAccount->setValueFieldVL(sfDomain, vucDomain);
} }
} }
@@ -162,21 +162,21 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
// TransferRate // TransferRate
// //
if (txn.getITFieldPresent(sfTransferRate)) if (txn.isFieldPresent(sfTransferRate))
{ {
uint32 uRate = txn.getITFieldU32(sfTransferRate); uint32 uRate = txn.getValueFieldU32(sfTransferRate);
if (!uRate || uRate == QUALITY_ONE) if (!uRate || uRate == QUALITY_ONE)
{ {
Log(lsINFO) << "doAccountSet: unset transfer rate"; Log(lsINFO) << "doAccountSet: unset transfer rate";
mTxnAccount->makeIFieldAbsent(sfTransferRate); mTxnAccount->makeFieldAbsent(sfTransferRate);
} }
else if (uRate > QUALITY_ONE) else if (uRate > QUALITY_ONE)
{ {
Log(lsINFO) << "doAccountSet: set transfer rate"; Log(lsINFO) << "doAccountSet: set transfer rate";
mTxnAccount->setIFieldU32(sfTransferRate, uRate); mTxnAccount->setValueFieldU32(sfTransferRate, uRate);
} }
else else
{ {
@@ -190,8 +190,8 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
// PublishHash && PublishSize // PublishHash && PublishSize
// //
bool bPublishHash = txn.getITFieldPresent(sfPublishHash); bool bPublishHash = txn.isFieldPresent(sfPublishHash);
bool bPublishSize = txn.getITFieldPresent(sfPublishSize); bool bPublishSize = txn.isFieldPresent(sfPublishSize);
if (bPublishHash ^ bPublishSize) if (bPublishHash ^ bPublishSize)
{ {
@@ -201,22 +201,22 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn)
} }
else if (bPublishHash && bPublishSize) else if (bPublishHash && bPublishSize)
{ {
uint256 uHash = txn.getITFieldH256(sfPublishHash); uint256 uHash = txn.getValueFieldH256(sfPublishHash);
uint32 uSize = txn.getITFieldU32(sfPublishSize); uint32 uSize = txn.getValueFieldU32(sfPublishSize);
if (!uHash) if (!uHash)
{ {
Log(lsINFO) << "doAccountSet: unset publish"; Log(lsINFO) << "doAccountSet: unset publish";
mTxnAccount->makeIFieldAbsent(sfPublishHash); mTxnAccount->makeFieldAbsent(sfPublishHash);
mTxnAccount->makeIFieldAbsent(sfPublishSize); mTxnAccount->makeFieldAbsent(sfPublishSize);
} }
else else
{ {
Log(lsINFO) << "doAccountSet: set publish"; Log(lsINFO) << "doAccountSet: set publish";
mTxnAccount->setIFieldH256(sfPublishHash, uHash); mTxnAccount->setValueFieldH256(sfPublishHash, uHash);
mTxnAccount->setIFieldU32(sfPublishSize, uSize); mTxnAccount->setValueFieldU32(sfPublishSize, uSize);
} }
} }
@@ -241,11 +241,11 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
TER terResult = tesSUCCESS; TER terResult = tesSUCCESS;
Log(lsINFO) << "doCreditSet>"; Log(lsINFO) << "doCreditSet>";
const STAmount saLimitAmount = txn.getITFieldAmount(sfLimitAmount); const STAmount saLimitAmount = txn.getValueFieldAmount(sfLimitAmount);
const bool bQualityIn = txn.getITFieldPresent(sfQualityIn); const bool bQualityIn = txn.isFieldPresent(sfQualityIn);
const uint32 uQualityIn = bQualityIn ? txn.getITFieldU32(sfQualityIn) : 0; const uint32 uQualityIn = bQualityIn ? txn.getValueFieldU32(sfQualityIn) : 0;
const bool bQualityOut = txn.getITFieldPresent(sfQualityOut); const bool bQualityOut = txn.isFieldPresent(sfQualityOut);
const uint32 uQualityOut = bQualityIn ? txn.getITFieldU32(sfQualityOut) : 0; const uint32 uQualityOut = bQualityIn ? txn.getValueFieldU32(sfQualityOut) : 0;
const uint160 uCurrencyID = saLimitAmount.getCurrency(); const uint160 uCurrencyID = saLimitAmount.getCurrency();
uint160 uDstAccountID = saLimitAmount.getIssuer(); uint160 uDstAccountID = saLimitAmount.getIssuer();
const bool bFlipped = mTxnAccountID > uDstAccountID; // true, iff current is not lowest. const bool bFlipped = mTxnAccountID > uDstAccountID; // true, iff current is not lowest.
@@ -285,12 +285,12 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
if (!saLimitAmount) if (!saLimitAmount)
{ {
// Zeroing line. // Zeroing line.
uint160 uLowID = sleRippleState->getIValueFieldAmount(sfLowLimit).getIssuer(); uint160 uLowID = sleRippleState->getValueFieldAmount(sfLowLimit).getIssuer();
uint160 uHighID = sleRippleState->getIValueFieldAmount(sfHighLimit).getIssuer(); uint160 uHighID = sleRippleState->getValueFieldAmount(sfHighLimit).getIssuer();
bool bLow = uLowID == uSrcAccountID; bool bLow = uLowID == uSrcAccountID;
bool bHigh = uLowID == uDstAccountID; bool bHigh = uLowID == uDstAccountID;
bool bBalanceZero = !sleRippleState->getIValueFieldAmount(sfBalance); bool bBalanceZero = !sleRippleState->getValueFieldAmount(sfBalance);
STAmount saDstLimit = sleRippleState->getIValueFieldAmount(bSendLow ? sfLowLimit : sfHighLimit); STAmount saDstLimit = sleRippleState->getValueFieldAmount(bSendLow ? sfLowLimit : sfHighLimit);
bool bDstLimitZero = !saDstLimit; bool bDstLimitZero = !saDstLimit;
assert(bLow || bHigh); assert(bLow || bHigh);
@@ -307,7 +307,7 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
if (!bDelIndex) if (!bDelIndex)
{ {
sleRippleState->setIFieldAmount(bFlipped ? sfHighLimit: sfLowLimit, saLimitAllow); sleRippleState->setValueFieldAmount(bFlipped ? sfHighLimit: sfLowLimit, saLimitAllow);
if (!bQualityIn) if (!bQualityIn)
{ {
@@ -315,11 +315,11 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
} }
else if (uQualityIn) else if (uQualityIn)
{ {
sleRippleState->setIFieldU32(bFlipped ? sfLowQualityIn : sfHighQualityIn, uQualityIn); sleRippleState->setValueFieldU32(bFlipped ? sfLowQualityIn : sfHighQualityIn, uQualityIn);
} }
else else
{ {
sleRippleState->makeIFieldAbsent(bFlipped ? sfLowQualityIn : sfHighQualityIn); sleRippleState->makeFieldAbsent(bFlipped ? sfLowQualityIn : sfHighQualityIn);
} }
if (!bQualityOut) if (!bQualityOut)
@@ -328,11 +328,11 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
} }
else if (uQualityOut) else if (uQualityOut)
{ {
sleRippleState->setIFieldU32(bFlipped ? sfLowQualityOut : sfHighQualityOut, uQualityOut); sleRippleState->setValueFieldU32(bFlipped ? sfLowQualityOut : sfHighQualityOut, uQualityOut);
} }
else else
{ {
sleRippleState->makeIFieldAbsent(bFlipped ? sfLowQualityOut : sfHighQualityOut); sleRippleState->makeFieldAbsent(bFlipped ? sfLowQualityOut : sfHighQualityOut);
} }
entryModify(sleRippleState); entryModify(sleRippleState);
@@ -354,14 +354,14 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn)
Log(lsINFO) << "doCreditSet: Creating ripple line: " << sleRippleState->getIndex().ToString(); Log(lsINFO) << "doCreditSet: Creating ripple line: " << sleRippleState->getIndex().ToString();
sleRippleState->setIFieldAmount(sfBalance, STAmount(uCurrencyID, ACCOUNT_ONE)); // Zero balance in currency. sleRippleState->setValueFieldAmount(sfBalance, STAmount(uCurrencyID, ACCOUNT_ONE)); // Zero balance in currency.
sleRippleState->setIFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, saLimitAllow); sleRippleState->setValueFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, saLimitAllow);
sleRippleState->setIFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uDstAccountID)); sleRippleState->setValueFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uDstAccountID));
if (uQualityIn) if (uQualityIn)
sleRippleState->setIFieldU32(bFlipped ? sfHighQualityIn : sfLowQualityIn, uQualityIn); sleRippleState->setValueFieldU32(bFlipped ? sfHighQualityIn : sfLowQualityIn, uQualityIn);
if (uQualityOut) if (uQualityOut)
sleRippleState->setIFieldU32(bFlipped ? sfHighQualityOut : sfLowQualityOut, uQualityOut); sleRippleState->setValueFieldU32(bFlipped ? sfHighQualityOut : sfLowQualityOut, uQualityOut);
uint64 uSrcRef; // Ignored, dirs never delete. uint64 uSrcRef; // Ignored, dirs never delete.
@@ -380,24 +380,24 @@ TER TransactionEngine::doNicknameSet(const SerializedTransaction& txn)
{ {
std::cerr << "doNicknameSet>" << std::endl; std::cerr << "doNicknameSet>" << std::endl;
const uint256 uNickname = txn.getITFieldH256(sfNickname); const uint256 uNickname = txn.getValueFieldH256(sfNickname);
const bool bMinOffer = txn.getITFieldPresent(sfMinimumOffer); const bool bMinOffer = txn.isFieldPresent(sfMinimumOffer);
const STAmount saMinOffer = bMinOffer ? txn.getITFieldAmount(sfAmount) : STAmount(); const STAmount saMinOffer = bMinOffer ? txn.getValueFieldAmount(sfAmount) : STAmount();
SLE::pointer sleNickname = entryCache(ltNICKNAME, uNickname); SLE::pointer sleNickname = entryCache(ltNICKNAME, uNickname);
if (sleNickname) if (sleNickname)
{ {
// Edit old entry. // Edit old entry.
sleNickname->setIFieldAccount(sfAccount, mTxnAccountID); sleNickname->setValueFieldAccount(sfAccount, mTxnAccountID);
if (bMinOffer && saMinOffer) if (bMinOffer && saMinOffer)
{ {
sleNickname->setIFieldAmount(sfMinimumOffer, saMinOffer); sleNickname->setValueFieldAmount(sfMinimumOffer, saMinOffer);
} }
else else
{ {
sleNickname->makeIFieldAbsent(sfMinimumOffer); sleNickname->makeFieldAbsent(sfMinimumOffer);
} }
entryModify(sleNickname); entryModify(sleNickname);
@@ -411,10 +411,10 @@ TER TransactionEngine::doNicknameSet(const SerializedTransaction& txn)
std::cerr << "doNicknameSet: Creating nickname node: " << sleNickname->getIndex().ToString() << std::endl; std::cerr << "doNicknameSet: Creating nickname node: " << sleNickname->getIndex().ToString() << std::endl;
sleNickname->setIFieldAccount(sfAccount, mTxnAccountID); sleNickname->setValueFieldAccount(sfAccount, mTxnAccountID);
if (bMinOffer && saMinOffer) if (bMinOffer && saMinOffer)
sleNickname->setIFieldAmount(sfMinimumOffer, saMinOffer); sleNickname->setValueFieldAmount(sfMinimumOffer, saMinOffer);
} }
std::cerr << "doNicknameSet<" << std::endl; std::cerr << "doNicknameSet<" << std::endl;
@@ -426,7 +426,7 @@ TER TransactionEngine::doPasswordFund(const SerializedTransaction& txn)
{ {
std::cerr << "doPasswordFund>" << std::endl; std::cerr << "doPasswordFund>" << std::endl;
const uint160 uDstAccountID = txn.getITFieldAccount(sfDestination); const uint160 uDstAccountID = txn.getValueFieldAccount160(sfDestination);
SLE::pointer sleDst = mTxnAccountID == uDstAccountID SLE::pointer sleDst = mTxnAccountID == uDstAccountID
? mTxnAccount ? mTxnAccount
: entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID)); : 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 bPartialPayment = isSetBit(uTxFlags, tfPartialPayment);
const bool bLimitQuality = isSetBit(uTxFlags, tfLimitQuality); const bool bLimitQuality = isSetBit(uTxFlags, tfLimitQuality);
const bool bNoRippleDirect = isSetBit(uTxFlags, tfNoRippleDirect); const bool bNoRippleDirect = isSetBit(uTxFlags, tfNoRippleDirect);
const bool bPaths = txn.getITFieldPresent(sfPaths); const bool bPaths = txn.isFieldPresent(sfPaths);
const bool bMax = txn.getITFieldPresent(sfSendMax); const bool bMax = txn.isFieldPresent(sfSendMax);
const uint160 uDstAccountID = txn.getITFieldAccount(sfDestination); const uint160 uDstAccountID = txn.getValueFieldAccount160(sfDestination);
const STAmount saDstAmount = txn.getITFieldAmount(sfAmount); const STAmount saDstAmount = txn.getValueFieldAmount(sfAmount);
const STAmount saMaxAmount = bMax ? txn.getITFieldAmount(sfSendMax) : saDstAmount; const STAmount saMaxAmount = bMax ? txn.getValueFieldAmount(sfSendMax) : saDstAmount;
const uint160 uSrcCurrency = saMaxAmount.getCurrency(); const uint160 uSrcCurrency = saMaxAmount.getCurrency();
const uint160 uDstCurrency = saDstAmount.getCurrency(); const uint160 uDstCurrency = saDstAmount.getCurrency();
@@ -550,8 +550,8 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac
// Create the account. // Create the account.
sleDst = entryCreate(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID)); sleDst = entryCreate(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID));
sleDst->setIFieldAccount(sfAccount, uDstAccountID); sleDst->setValueFieldAccount(sfAccount, uDstAccountID);
sleDst->setIFieldU32(sfSequence, 1); sleDst->setValueFieldU32(sfSequence, 1);
} }
else else
{ {
@@ -566,7 +566,7 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac
{ {
// Ripple payment // Ripple payment
STPathSet spsPaths = txn.getITFieldPathSet(sfPaths); STPathSet spsPaths = txn.getValueFieldPathSet(sfPaths);
STAmount saMaxAmountAct; STAmount saMaxAmountAct;
STAmount saDstAmountAct; STAmount saDstAmountAct;
@@ -589,7 +589,7 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac
{ {
// Direct XNS payment. // Direct XNS payment.
STAmount saSrcXNSBalance = mTxnAccount->getIValueFieldAmount(sfBalance); STAmount saSrcXNSBalance = mTxnAccount->getValueFieldAmount(sfBalance);
if (saSrcXNSBalance < saDstAmount) if (saSrcXNSBalance < saDstAmount)
{ {
@@ -600,8 +600,8 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac
} }
else else
{ {
mTxnAccount->setIFieldAmount(sfBalance, saSrcXNSBalance - saDstAmount); mTxnAccount->setValueFieldAmount(sfBalance, saSrcXNSBalance - saDstAmount);
sleDst->setIFieldAmount(sfBalance, sleDst->getIValueFieldAmount(sfBalance) + saDstAmount); sleDst->setValueFieldAmount(sfBalance, sleDst->getValueFieldAmount(sfBalance) + saDstAmount);
terResult = tesSUCCESS; terResult = tesSUCCESS;
} }
@@ -626,9 +626,9 @@ TER TransactionEngine::doWalletAdd(const SerializedTransaction& txn)
{ {
std::cerr << "WalletAdd>" << std::endl; std::cerr << "WalletAdd>" << std::endl;
const std::vector<unsigned char> vucPubKey = txn.getITFieldVL(sfPublicKey); const std::vector<unsigned char> vucPubKey = txn.getValueFieldVL(sfPublicKey);
const std::vector<unsigned char> vucSignature = txn.getITFieldVL(sfSignature); const std::vector<unsigned char> vucSignature = txn.getValueFieldVL(sfSignature);
const uint160 uAuthKeyID = txn.getITFieldAccount(sfAuthorizedKey); const uint160 uAuthKeyID = txn.getValueFieldAccount160(sfAuthorizedKey);
const NewcoinAddress naMasterPubKey = NewcoinAddress::createAccountPublic(vucPubKey); const NewcoinAddress naMasterPubKey = NewcoinAddress::createAccountPublic(vucPubKey);
const uint160 uDstAccountID = naMasterPubKey.getAccountID(); const uint160 uDstAccountID = naMasterPubKey.getAccountID();
@@ -648,8 +648,8 @@ TER TransactionEngine::doWalletAdd(const SerializedTransaction& txn)
return tefCREATED; return tefCREATED;
} }
STAmount saAmount = txn.getITFieldAmount(sfAmount); STAmount saAmount = txn.getValueFieldAmount(sfAmount);
STAmount saSrcBalance = mTxnAccount->getIValueFieldAmount(sfBalance); STAmount saSrcBalance = mTxnAccount->getValueFieldAmount(sfBalance);
if (saSrcBalance < saAmount) if (saSrcBalance < saAmount)
{ {
@@ -663,15 +663,15 @@ TER TransactionEngine::doWalletAdd(const SerializedTransaction& txn)
} }
// Deduct initial balance from source account. // Deduct initial balance from source account.
mTxnAccount->setIFieldAmount(sfBalance, saSrcBalance-saAmount); mTxnAccount->setValueFieldAmount(sfBalance, saSrcBalance-saAmount);
// Create the account. // Create the account.
sleDst = entryCreate(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID)); sleDst = entryCreate(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID));
sleDst->setIFieldAccount(sfAccount, uDstAccountID); sleDst->setValueFieldAccount(sfAccount, uDstAccountID);
sleDst->setIFieldU32(sfSequence, 1); sleDst->setValueFieldU32(sfSequence, 1);
sleDst->setIFieldAmount(sfBalance, saAmount); sleDst->setValueFieldAmount(sfBalance, saAmount);
sleDst->setIFieldAccount(sfAuthorizedKey, uAuthKeyID); sleDst->setValueFieldAccount(sfAuthorizedKey, uAuthKeyID);
std::cerr << "WalletAdd<" << std::endl; std::cerr << "WalletAdd<" << std::endl;
@@ -770,11 +770,11 @@ TER TransactionEngine::takeOffers(
Log(lsINFO) << "takeOffers: considering offer : " << sleOffer->getJson(0); Log(lsINFO) << "takeOffers: considering offer : " << sleOffer->getJson(0);
const uint160 uOfferOwnerID = sleOffer->getIValueFieldAccount(sfAccount).getAccountID(); const uint160 uOfferOwnerID = sleOffer->getValueFieldAccount(sfAccount).getAccountID();
STAmount saOfferPays = sleOffer->getIValueFieldAmount(sfTakerGets); STAmount saOfferPays = sleOffer->getValueFieldAmount(sfTakerGets);
STAmount saOfferGets = sleOffer->getIValueFieldAmount(sfTakerPays); 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. // Offer is expired. Expired offers are considered unfunded. Delete it.
Log(lsINFO) << "takeOffers: encountered expired offer"; Log(lsINFO) << "takeOffers: encountered expired offer";
@@ -849,10 +849,10 @@ TER TransactionEngine::takeOffers(
// Adjust offer // Adjust offer
// Offer owner will pay less. Subtract what taker just got. // 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. // Offer owner will get less. Subtract what owner just paid.
sleOffer->setIFieldAmount(sfTakerPays, saOfferGets -= saSubTakerPaid); sleOffer->setValueFieldAmount(sfTakerPays, saOfferGets -= saSubTakerPaid);
entryModify(sleOffer); entryModify(sleOffer);
@@ -919,8 +919,8 @@ TER TransactionEngine::doOfferCreate(const SerializedTransaction& txn)
Log(lsWARNING) << "doOfferCreate> " << txn.getJson(0); Log(lsWARNING) << "doOfferCreate> " << txn.getJson(0);
const uint32 txFlags = txn.getFlags(); const uint32 txFlags = txn.getFlags();
const bool bPassive = isSetBit(txFlags, tfPassive); const bool bPassive = isSetBit(txFlags, tfPassive);
STAmount saTakerPays = txn.getITFieldAmount(sfTakerPays); STAmount saTakerPays = txn.getValueFieldAmount(sfTakerPays);
STAmount saTakerGets = txn.getITFieldAmount(sfTakerGets); STAmount saTakerGets = txn.getValueFieldAmount(sfTakerGets);
Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGets=%s") Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGets=%s")
% saTakerPays.getFullText() % saTakerPays.getFullText()
@@ -928,8 +928,8 @@ Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGe
const uint160 uPaysIssuerID = saTakerPays.getIssuer(); const uint160 uPaysIssuerID = saTakerPays.getIssuer();
const uint160 uGetsIssuerID = saTakerGets.getIssuer(); const uint160 uGetsIssuerID = saTakerGets.getIssuer();
const uint32 uExpiration = txn.getITFieldU32(sfExpiration); const uint32 uExpiration = txn.getValueFieldU32(sfExpiration);
const bool bHaveExpiration = txn.getITFieldPresent(sfExpiration); const bool bHaveExpiration = txn.isFieldPresent(sfExpiration);
const uint32 uSequence = txn.getSequence(); const uint32 uSequence = txn.getSequence();
const uint256 uLedgerIndex = Ledger::getOfferIndex(mTxnAccountID, uSequence); 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: uPaysCurrency=" << saTakerPays.getHumanCurrency();
Log(lsWARNING) << "doOfferCreate: uGetsCurrency=" << saTakerGets.getHumanCurrency(); Log(lsWARNING) << "doOfferCreate: uGetsCurrency=" << saTakerGets.getHumanCurrency();
sleOffer->setIFieldAccount(sfAccount, mTxnAccountID); sleOffer->setValueFieldAccount(sfAccount, mTxnAccountID);
sleOffer->setIFieldU32(sfSequence, uSequence); sleOffer->setValueFieldU32(sfSequence, uSequence);
sleOffer->setIFieldH256(sfBookDirectory, uDirectory); sleOffer->setValueFieldH256(sfBookDirectory, uDirectory);
sleOffer->setIFieldAmount(sfTakerPays, saTakerPays); sleOffer->setValueFieldAmount(sfTakerPays, saTakerPays);
sleOffer->setIFieldAmount(sfTakerGets, saTakerGets); sleOffer->setValueFieldAmount(sfTakerGets, saTakerGets);
sleOffer->setIFieldU64(sfOwnerNode, uOwnerNode); sleOffer->setValueFieldU64(sfOwnerNode, uOwnerNode);
sleOffer->setIFieldU64(sfBookNode, uBookNode); sleOffer->setValueFieldU64(sfBookNode, uBookNode);
if (uExpiration) if (uExpiration)
sleOffer->setIFieldU32(sfExpiration, uExpiration); sleOffer->setValueFieldU32(sfExpiration, uExpiration);
if (bPassive) if (bPassive)
sleOffer->setFlag(lsfPassive); sleOffer->setFlag(lsfPassive);
@@ -1114,7 +1114,7 @@ Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGe
TER TransactionEngine::doOfferCancel(const SerializedTransaction& txn) TER TransactionEngine::doOfferCancel(const SerializedTransaction& txn)
{ {
TER terResult; TER terResult;
const uint32 uSequence = txn.getITFieldU32(sfOfferSequence); const uint32 uSequence = txn.getValueFieldU32(sfOfferSequence);
const uint256 uOfferIndex = Ledger::getOfferIndex(mTxnAccountID, uSequence); const uint256 uOfferIndex = Ledger::getOfferIndex(mTxnAccountID, uSequence);
SLE::pointer sleOffer = entryCache(ltOFFER, uOfferIndex); SLE::pointer sleOffer = entryCache(ltOFFER, uOfferIndex);
@@ -1141,14 +1141,14 @@ TER TransactionEngine::doContractAdd(const SerializedTransaction& txn)
{ {
Log(lsWARNING) << "doContractAdd> " << txn.getJson(0); Log(lsWARNING) << "doContractAdd> " << txn.getJson(0);
const uint32 expiration = txn.getITFieldU32(sfExpiration); const uint32 expiration = txn.getValueFieldU32(sfExpiration);
// const uint32 bondAmount = txn.getITFieldU32(sfBondAmount); // const uint32 bondAmount = txn.getValueFieldU32(sfBondAmount);
// const uint32 stampEscrow = txn.getITFieldU32(sfStampEscrow); // const uint32 stampEscrow = txn.getValueFieldU32(sfStampEscrow);
STAmount rippleEscrow = txn.getITFieldAmount(sfRippleEscrow); STAmount rippleEscrow = txn.getValueFieldAmount(sfRippleEscrow);
std::vector<unsigned char> createCode = txn.getITFieldVL(sfCreateCode); std::vector<unsigned char> createCode = txn.getValueFieldVL(sfCreateCode);
std::vector<unsigned char> fundCode = txn.getITFieldVL(sfFundCode); std::vector<unsigned char> fundCode = txn.getValueFieldVL(sfFundCode);
std::vector<unsigned char> removeCode = txn.getITFieldVL(sfRemoveCode); std::vector<unsigned char> removeCode = txn.getValueFieldVL(sfRemoveCode);
std::vector<unsigned char> expireCode = txn.getITFieldVL(sfExpireCode); std::vector<unsigned char> expireCode = txn.getValueFieldVL(sfExpireCode);
// make sure // make sure
// expiration hasn't passed // expiration hasn't passed

14
src/TransactionEngine.cpp
View File

@@ -136,7 +136,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
case ttNICKNAME_SET: case ttNICKNAME_SET:
{ {
SLE::pointer sleNickname = entryCache(ltNICKNAME, txn.getITFieldH256(sfNickname)); SLE::pointer sleNickname = entryCache(ltNICKNAME, txn.getValueFieldH256(sfNickname));
if (!sleNickname) if (!sleNickname)
saCost = theConfig.FEE_NICKNAME_CREATE; saCost = theConfig.FEE_NICKNAME_CREATE;
@@ -222,8 +222,8 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
} }
else else
{ {
saSrcBalance = mTxnAccount->getIValueFieldAmount(sfBalance); saSrcBalance = mTxnAccount->getValueFieldAmount(sfBalance);
bHaveAuthKey = mTxnAccount->getIFieldPresent(sfAuthorizedKey); bHaveAuthKey = mTxnAccount->isFieldPresent(sfAuthorizedKey);
} }
// Check if account claimed. // Check if account claimed.
@@ -279,7 +279,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
default: default:
// Verify the transaction's signing public key is the key authorized for signing. // 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. // Authorized to continue.
nothing(); nothing();
@@ -322,7 +322,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
} }
else else
{ {
mTxnAccount->setIFieldAmount(sfBalance, saSrcBalance - saPaid); mTxnAccount->setValueFieldAmount(sfBalance, saSrcBalance - saPaid);
} }
// Validate sequence // Validate sequence
@@ -332,7 +332,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
} }
else if (saCost) else if (saCost)
{ {
uint32 a_seq = mTxnAccount->getIFieldU32(sfSequence); uint32 a_seq = mTxnAccount->getValueFieldU32(sfSequence);
Log(lsTRACE) << "Aseq=" << a_seq << ", Tseq=" << t_seq; Log(lsTRACE) << "Aseq=" << a_seq << ", Tseq=" << t_seq;
@@ -359,7 +359,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa
} }
else else
{ {
mTxnAccount->setIFieldU32(sfSequence, t_seq + 1); mTxnAccount->setValueFieldU32(sfSequence, t_seq + 1);
} }
} }
else else