From 79c35f2689b18bfdc405489af97c00dfa0e40ae2 Mon Sep 17 00:00:00 2001 From: JoelKatz Date: Mon, 1 Oct 2012 15:21:22 -0700 Subject: [PATCH] Remove all IField/ITField functions. They are now obsolete. Use the correponding STObject functions. --- src/AccountState.cpp | 6 +- src/AccountState.h | 8 +- src/Ledger.cpp | 4 +- src/LedgerEntrySet.cpp | 108 ++++++++--------- src/NetworkOPs.cpp | 14 +-- src/NicknameState.cpp | 8 +- src/OrderBook.cpp | 4 +- src/RPCServer.cpp | 4 +- src/RippleCalc.cpp | 28 ++--- src/RippleLines.cpp | 4 +- src/RippleState.cpp | 14 +-- src/SerializedLedger.cpp | 4 +- src/SerializedLedger.h | 44 ------- src/SerializedObject.cpp | 22 ++++ src/SerializedObject.h | 1 + src/SerializedTransaction.cpp | 9 -- src/SerializedTransaction.h | 45 ------- src/Transaction.cpp | 78 ++++++------ src/Transaction.h | 18 +-- src/TransactionAction.cpp | 216 +++++++++++++++++----------------- src/TransactionEngine.cpp | 14 +-- 21 files changed, 289 insertions(+), 364 deletions(-) diff --git a/src/AccountState.cpp b/src/AccountState.cpp index 85ad825fed..42acd03d42 100644 --- a/src/AccountState.cpp +++ b/src/AccountState.cpp @@ -17,7 +17,7 @@ AccountState::AccountState(const NewcoinAddress& naAccountID) : mAccountID(naAcc mLedgerEntry = boost::make_shared(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 { diff --git a/src/AccountState.h b/src/AccountState.h index 5559990a72..b0d68205bb 100644 --- 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; } diff --git a/src/Ledger.cpp b/src/Ledger.cpp index 8d7dec92bf..f9c4bf343f 100644 --- 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(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:"; diff --git a/src/LedgerEntrySet.cpp b/src/LedgerEntrySet.cpp index c64b90d972..5147ed6286 100644 --- 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& vuiIndexes = svIndexes.peekValue(); std::vector::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& 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 diff --git a/src/NetworkOPs.cpp b/src/NetworkOPs.cpp index 7985e2dbe6..c645fd1fbb 100644 --- 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& 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; diff --git a/src/NicknameState.cpp b/src/NicknameState.cpp index 9b2cb3e857..e1dcb39aa8 100644 --- 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) diff --git a/src/OrderBook.cpp b/src/OrderBook.cpp index d349609107..9c032b9670 100644 --- 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(); diff --git a/src/RPCServer.cpp b/src/RPCServer.cpp index 8936231c2c..cc9d1aa568 100644 --- 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 vucCipher = sleGen->getIFieldVL(sfGenerator); + std::vector vucCipher = sleGen->getValueFieldVL(sfGenerator); std::vector 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 vucCipher = sleGen->getIFieldVL(sfGenerator); + std::vector vucCipher = sleGen->getValueFieldVL(sfGenerator); std::vector vucMasterGenerator = naRegular0Private.accountPrivateDecrypt(naRegular0Public, vucCipher); if (vucMasterGenerator.empty()) { diff --git a/src/RippleCalc.cpp b/src/RippleCalc.cpp index 3a1b1cc2f2..1292964cb4 100644 --- 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"; diff --git a/src/RippleLines.cpp b/src/RippleLines.cpp index 391d38c02d..e66168f58e 100644 --- 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); diff --git a/src/RippleState.cpp b/src/RippleState.cpp index 72b9efd10d..911a7380ee 100644 --- 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; } diff --git a/src/SerializedLedger.cpp b/src/SerializedLedger.cpp index 4ba43bd1e3..4b854d2384 100644 --- 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 SerializedLedgerEntry::getOwners() diff --git a/src/SerializedLedger.h b/src/SerializedLedger.h index b7f35a34f4..455830661e 100644 --- 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 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 getIFieldVL(SField::ref field) const { return getValueFieldVL(field); } - std::vector 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& v) - { return setValueFieldVL(field, v); } - void setIFieldTL(SField::ref field, const std::vector& 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; diff --git a/src/SerializedObject.cpp b/src/SerializedObject.cpp index 0bfab6c928..5cf6a4e7dc 100644 --- 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(rf); + if (!cf) throw std::runtime_error("Wrong field type"); + cf->getValueH160(a); + } + return a; +} + std::vector STObject::getValueFieldVL(SField::ref field) const { const SerializedType* rf = peekAtPField(field); diff --git a/src/SerializedObject.h b/src/SerializedObject.h index 58a926d983..321e8c1c78 100644 --- 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 getValueFieldVL(SField::ref field) const; std::vector getValueFieldTL(SField::ref field) const; STAmount getValueFieldAmount(SField::ref field) const; diff --git a/src/SerializedTransaction.cpp b/src/SerializedTransaction.cpp index aca26946ca..5059848b46 100644 --- 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(peekAtPField(field)); - if (ac) - ac->getValueH160(r); - return r; -} - Json::Value SerializedTransaction::getJson(int options) const { Json::Value ret = STObject::getJson(0); diff --git a/src/SerializedTransaction.h b/src/SerializedTransaction.h index 295d0eb3cb..f38f9c73fd 100644 --- 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 getITFieldVL(SField::ref field) const { return getValueFieldVL(field); } - std::vector 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& v) - { return setValueFieldVL(field, v); } - void setITFieldTL(SField::ref field, const std::vector& 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 getAffectedAccounts() const; uint256 getTransactionID() const; diff --git a/src/Transaction.cpp b/src/Transaction.cpp index ec209bdf16..81586f7280 100644 --- 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& vucPubKey, const std::vector& 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& 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& vucPubKey, const std::vector& 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& 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); diff --git a/src/Transaction.h b/src/Transaction.h index d8dc7fa7cc..2e97d20940 100644 --- 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 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 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; } diff --git a/src/TransactionAction.cpp b/src/TransactionAction.cpp index 190a66bb3f..64dd343863 100644 --- 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 vucCipher = txn.getITFieldVL(sfGenerator); - std::vector vucPubKey = txn.getITFieldVL(sfPublicKey); - std::vector vucSignature = txn.getITFieldVL(sfSignature); + std::vector vucCipher = txn.getValueFieldVL(sfGenerator); + std::vector vucPubKey = txn.getValueFieldVL(sfPublicKey); + std::vector 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 vucDomain = txn.getITFieldVL(sfDomain); + std::vector 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 vucPubKey = txn.getITFieldVL(sfPublicKey); - const std::vector vucSignature = txn.getITFieldVL(sfSignature); - const uint160 uAuthKeyID = txn.getITFieldAccount(sfAuthorizedKey); + const std::vector vucPubKey = txn.getValueFieldVL(sfPublicKey); + const std::vector 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 createCode = txn.getITFieldVL(sfCreateCode); - std::vector fundCode = txn.getITFieldVL(sfFundCode); - std::vector removeCode = txn.getITFieldVL(sfRemoveCode); - std::vector 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 createCode = txn.getValueFieldVL(sfCreateCode); + std::vector fundCode = txn.getValueFieldVL(sfFundCode); + std::vector removeCode = txn.getValueFieldVL(sfRemoveCode); + std::vector expireCode = txn.getValueFieldVL(sfExpireCode); // make sure // expiration hasn't passed diff --git a/src/TransactionEngine.cpp b/src/TransactionEngine.cpp index 8847ca87e1..6452ca0775 100644 --- 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