mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-20 11:05:54 +00:00
1646 lines
55 KiB
C++
1646 lines
55 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
Copyright (c) 2011-2013, OpenCoin, Inc.
|
|
*/
|
|
//==============================================================================
|
|
|
|
SETUP_LOG (LedgerEntrySet)
|
|
|
|
// #define META_DEBUG
|
|
|
|
// VFALCO TODO Replace this macro with a documented language constant
|
|
// NOTE Is this part of the protocol?
|
|
//
|
|
#define DIR_NODE_MAX 32
|
|
|
|
void LedgerEntrySet::init (Ledger::ref ledger, uint256 const& transactionID,
|
|
uint32 ledgerID, TransactionEngineParams params)
|
|
{
|
|
mEntries.clear ();
|
|
mLedger = ledger;
|
|
mSet.init (transactionID, ledgerID);
|
|
mParams = params;
|
|
mSeq = 0;
|
|
}
|
|
|
|
void LedgerEntrySet::clear ()
|
|
{
|
|
mEntries.clear ();
|
|
mSet.clear ();
|
|
}
|
|
|
|
LedgerEntrySet LedgerEntrySet::duplicate () const
|
|
{
|
|
return LedgerEntrySet (mLedger, mEntries, mSet, mSeq + 1);
|
|
}
|
|
|
|
void LedgerEntrySet::setTo (const LedgerEntrySet& e)
|
|
{
|
|
mLedger = e.mLedger;
|
|
mEntries = e.mEntries;
|
|
mSet = e.mSet;
|
|
mParams = e.mParams;
|
|
mSeq = e.mSeq;
|
|
}
|
|
|
|
void LedgerEntrySet::swapWith (LedgerEntrySet& e)
|
|
{
|
|
std::swap (mLedger, e.mLedger);
|
|
mEntries.swap (e.mEntries);
|
|
mSet.swap (e.mSet);
|
|
std::swap (mParams, e.mParams);
|
|
std::swap (mSeq, e.mSeq);
|
|
}
|
|
|
|
// Find an entry in the set. If it has the wrong sequence number, copy it and update the sequence number.
|
|
// This is basically: copy-on-read.
|
|
SLE::pointer LedgerEntrySet::getEntry (uint256 const& index, LedgerEntryAction& action)
|
|
{
|
|
std::map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find (index);
|
|
|
|
if (it == mEntries.end ())
|
|
{
|
|
action = taaNONE;
|
|
return SLE::pointer ();
|
|
}
|
|
|
|
if (it->second.mSeq != mSeq)
|
|
{
|
|
assert (it->second.mSeq < mSeq);
|
|
it->second.mEntry = boost::make_shared<SerializedLedgerEntry> (*it->second.mEntry);
|
|
it->second.mSeq = mSeq;
|
|
}
|
|
|
|
action = it->second.mAction;
|
|
return it->second.mEntry;
|
|
}
|
|
|
|
SLE::pointer LedgerEntrySet::entryCreate (LedgerEntryType letType, uint256 const& index)
|
|
{
|
|
assert (index.isNonZero ());
|
|
SLE::pointer sleNew = boost::make_shared<SLE> (letType, index);
|
|
entryCreate (sleNew);
|
|
return sleNew;
|
|
}
|
|
|
|
SLE::pointer LedgerEntrySet::entryCache (LedgerEntryType letType, uint256 const& index)
|
|
{
|
|
assert (mLedger);
|
|
SLE::pointer sleEntry;
|
|
|
|
if (index.isNonZero ())
|
|
{
|
|
LedgerEntryAction action;
|
|
sleEntry = getEntry (index, action);
|
|
|
|
if (!sleEntry)
|
|
{
|
|
assert (action != taaDELETE);
|
|
sleEntry = mImmutable ? mLedger->getSLEi (index) : mLedger->getSLE (index);
|
|
|
|
if (sleEntry)
|
|
entryCache (sleEntry);
|
|
}
|
|
else if (action == taaDELETE)
|
|
sleEntry.reset ();
|
|
}
|
|
|
|
return sleEntry;
|
|
}
|
|
|
|
LedgerEntryAction LedgerEntrySet::hasEntry (uint256 const& index) const
|
|
{
|
|
std::map<uint256, LedgerEntrySetEntry>::const_iterator it = mEntries.find (index);
|
|
|
|
if (it == mEntries.end ())
|
|
return taaNONE;
|
|
|
|
return it->second.mAction;
|
|
}
|
|
|
|
void LedgerEntrySet::entryCache (SLE::ref sle)
|
|
{
|
|
assert (mLedger);
|
|
assert (sle->isMutable () || mImmutable); // Don't put an immutable SLE in a mutable LES
|
|
std::map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find (sle->getIndex ());
|
|
|
|
if (it == mEntries.end ())
|
|
{
|
|
mEntries.insert (std::make_pair (sle->getIndex (), LedgerEntrySetEntry (sle, taaCACHED, mSeq)));
|
|
return;
|
|
}
|
|
|
|
switch (it->second.mAction)
|
|
{
|
|
case taaCACHED:
|
|
assert (sle == it->second.mEntry);
|
|
it->second.mSeq = mSeq;
|
|
it->second.mEntry = sle;
|
|
return;
|
|
|
|
default:
|
|
throw std::runtime_error ("Cache after modify/delete/create");
|
|
}
|
|
}
|
|
|
|
void LedgerEntrySet::entryCreate (SLE::ref sle)
|
|
{
|
|
assert (mLedger && !mImmutable);
|
|
assert (sle->isMutable ());
|
|
std::map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find (sle->getIndex ());
|
|
|
|
if (it == mEntries.end ())
|
|
{
|
|
mEntries.insert (std::make_pair (sle->getIndex (), LedgerEntrySetEntry (sle, taaCREATE, mSeq)));
|
|
return;
|
|
}
|
|
|
|
switch (it->second.mAction)
|
|
{
|
|
|
|
case taaDELETE:
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << "Create after Delete = Modify";
|
|
it->second.mEntry = sle;
|
|
it->second.mAction = taaMODIFY;
|
|
it->second.mSeq = mSeq;
|
|
break;
|
|
|
|
case taaMODIFY:
|
|
throw std::runtime_error ("Create after modify");
|
|
|
|
case taaCREATE:
|
|
throw std::runtime_error ("Create after create"); // This could be made to work
|
|
|
|
case taaCACHED:
|
|
throw std::runtime_error ("Create after cache");
|
|
|
|
default:
|
|
throw std::runtime_error ("Unknown taa");
|
|
}
|
|
|
|
assert (it->second.mSeq == mSeq);
|
|
}
|
|
|
|
void LedgerEntrySet::entryModify (SLE::ref sle)
|
|
{
|
|
assert (sle->isMutable () && !mImmutable);
|
|
assert (mLedger);
|
|
std::map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find (sle->getIndex ());
|
|
|
|
if (it == mEntries.end ())
|
|
{
|
|
mEntries.insert (std::make_pair (sle->getIndex (), LedgerEntrySetEntry (sle, taaMODIFY, mSeq)));
|
|
return;
|
|
}
|
|
|
|
assert (it->second.mSeq == mSeq);
|
|
assert (it->second.mEntry == sle);
|
|
|
|
switch (it->second.mAction)
|
|
{
|
|
case taaCACHED:
|
|
it->second.mAction = taaMODIFY;
|
|
fallthru ();
|
|
|
|
case taaCREATE:
|
|
case taaMODIFY:
|
|
it->second.mSeq = mSeq;
|
|
it->second.mEntry = sle;
|
|
break;
|
|
|
|
case taaDELETE:
|
|
throw std::runtime_error ("Modify after delete");
|
|
|
|
default:
|
|
throw std::runtime_error ("Unknown taa");
|
|
}
|
|
}
|
|
|
|
void LedgerEntrySet::entryDelete (SLE::ref sle)
|
|
{
|
|
assert (sle->isMutable () && !mImmutable);
|
|
assert (mLedger);
|
|
std::map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find (sle->getIndex ());
|
|
|
|
if (it == mEntries.end ())
|
|
{
|
|
assert (false); // deleting an entry not cached?
|
|
mEntries.insert (std::make_pair (sle->getIndex (), LedgerEntrySetEntry (sle, taaDELETE, mSeq)));
|
|
return;
|
|
}
|
|
|
|
assert (it->second.mSeq == mSeq);
|
|
assert (it->second.mEntry == sle);
|
|
|
|
switch (it->second.mAction)
|
|
{
|
|
case taaCACHED:
|
|
case taaMODIFY:
|
|
it->second.mSeq = mSeq;
|
|
it->second.mEntry = sle;
|
|
it->second.mAction = taaDELETE;
|
|
break;
|
|
|
|
case taaCREATE:
|
|
mEntries.erase (it);
|
|
break;
|
|
|
|
case taaDELETE:
|
|
break;
|
|
|
|
default:
|
|
throw std::runtime_error ("Unknown taa");
|
|
}
|
|
}
|
|
|
|
bool LedgerEntrySet::hasChanges ()
|
|
{
|
|
typedef std::map<uint256, LedgerEntrySetEntry>::value_type u256_LES_pair;
|
|
BOOST_FOREACH (u256_LES_pair & it, mEntries)
|
|
|
|
if (it.second.mAction != taaCACHED)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LedgerEntrySet::intersect (const LedgerEntrySet& lesLeft, const LedgerEntrySet& lesRight)
|
|
{
|
|
return true; // XXX Needs implementation
|
|
}
|
|
|
|
Json::Value LedgerEntrySet::getJson (int) const
|
|
{
|
|
Json::Value ret (Json::objectValue);
|
|
|
|
Json::Value nodes (Json::arrayValue);
|
|
|
|
for (std::map<uint256, LedgerEntrySetEntry>::const_iterator it = mEntries.begin (),
|
|
end = mEntries.end (); it != end; ++it)
|
|
{
|
|
Json::Value entry (Json::objectValue);
|
|
entry["node"] = it->first.GetHex ();
|
|
|
|
switch (it->second.mEntry->getType ())
|
|
{
|
|
case ltINVALID:
|
|
entry["type"] = "invalid";
|
|
break;
|
|
|
|
case ltACCOUNT_ROOT:
|
|
entry["type"] = "acccount_root";
|
|
break;
|
|
|
|
case ltDIR_NODE:
|
|
entry["type"] = "dir_node";
|
|
break;
|
|
|
|
case ltGENERATOR_MAP:
|
|
entry["type"] = "generator_map";
|
|
break;
|
|
|
|
case ltRIPPLE_STATE:
|
|
entry["type"] = "ripple_state";
|
|
break;
|
|
|
|
case ltNICKNAME:
|
|
entry["type"] = "nickname";
|
|
break;
|
|
|
|
case ltOFFER:
|
|
entry["type"] = "offer";
|
|
break;
|
|
|
|
default:
|
|
assert (false);
|
|
}
|
|
|
|
switch (it->second.mAction)
|
|
{
|
|
case taaCACHED:
|
|
entry["action"] = "cache";
|
|
break;
|
|
|
|
case taaMODIFY:
|
|
entry["action"] = "modify";
|
|
break;
|
|
|
|
case taaDELETE:
|
|
entry["action"] = "delete";
|
|
break;
|
|
|
|
case taaCREATE:
|
|
entry["action"] = "create";
|
|
break;
|
|
|
|
default:
|
|
assert (false);
|
|
}
|
|
|
|
nodes.append (entry);
|
|
}
|
|
|
|
ret["nodes" ] = nodes;
|
|
|
|
ret["metaData"] = mSet.getJson (0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
SLE::pointer LedgerEntrySet::getForMod (uint256 const& node, Ledger::ref ledger,
|
|
boost::unordered_map<uint256, SLE::pointer>& newMods)
|
|
{
|
|
std::map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find (node);
|
|
|
|
if (it != mEntries.end ())
|
|
{
|
|
if (it->second.mAction == taaDELETE)
|
|
{
|
|
WriteLog (lsFATAL, LedgerEntrySet) << "Trying to thread to deleted node";
|
|
return SLE::pointer ();
|
|
}
|
|
|
|
if (it->second.mAction == taaCACHED)
|
|
it->second.mAction = taaMODIFY;
|
|
|
|
if (it->second.mSeq != mSeq)
|
|
{
|
|
it->second.mEntry = boost::make_shared<SerializedLedgerEntry> (*it->second.mEntry);
|
|
it->second.mSeq = mSeq;
|
|
}
|
|
|
|
return it->second.mEntry;
|
|
}
|
|
|
|
boost::unordered_map<uint256, SLE::pointer>::iterator me = newMods.find (node);
|
|
|
|
if (me != newMods.end ())
|
|
{
|
|
assert (me->second);
|
|
return me->second;
|
|
}
|
|
|
|
SLE::pointer ret = ledger->getSLE (node);
|
|
|
|
if (ret)
|
|
newMods.insert (std::make_pair (node, ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
bool LedgerEntrySet::threadTx (const RippleAddress& threadTo, Ledger::ref ledger,
|
|
boost::unordered_map<uint256, SLE::pointer>& newMods)
|
|
{
|
|
#ifdef META_DEBUG
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "Thread to " << threadTo.getAccountID ();
|
|
#endif
|
|
SLE::pointer sle = getForMod (Ledger::getAccountRootIndex (threadTo.getAccountID ()), ledger, newMods);
|
|
|
|
if (!sle)
|
|
{
|
|
WriteLog (lsFATAL, LedgerEntrySet) << "Threading to non-existent account: " << threadTo.humanAccountID ();
|
|
assert (false);
|
|
return false;
|
|
}
|
|
|
|
return threadTx (sle, ledger, newMods);
|
|
}
|
|
|
|
bool LedgerEntrySet::threadTx (SLE::ref threadTo, Ledger::ref ledger,
|
|
boost::unordered_map<uint256, SLE::pointer>& newMods)
|
|
{
|
|
// node = the node that was modified/deleted/created
|
|
// threadTo = the node that needs to know
|
|
uint256 prevTxID;
|
|
uint32 prevLgrID;
|
|
|
|
if (!threadTo->thread (mSet.getTxID (), mSet.getLgrSeq (), prevTxID, prevLgrID))
|
|
return false;
|
|
|
|
if (prevTxID.isZero () ||
|
|
TransactionMetaSet::thread (mSet.getAffectedNode (threadTo, sfModifiedNode), prevTxID, prevLgrID))
|
|
return true;
|
|
|
|
assert (false);
|
|
return false;
|
|
}
|
|
|
|
bool LedgerEntrySet::threadOwners (SLE::ref node, Ledger::ref ledger,
|
|
boost::unordered_map<uint256, SLE::pointer>& newMods)
|
|
{
|
|
// thread new or modified node to owner or owners
|
|
if (node->hasOneOwner ()) // thread to owner's account
|
|
{
|
|
#ifdef META_DEBUG
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "Thread to single owner";
|
|
#endif
|
|
return threadTx (node->getOwner (), ledger, newMods);
|
|
}
|
|
else if (node->hasTwoOwners ()) // thread to owner's accounts
|
|
{
|
|
#ifdef META_DEBUG
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "Thread to two owners";
|
|
#endif
|
|
return
|
|
threadTx (node->getFirstOwner (), ledger, newMods) &&
|
|
threadTx (node->getSecondOwner (), ledger, newMods);
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
void LedgerEntrySet::calcRawMeta (Serializer& s, TER result, uint32 index)
|
|
{
|
|
// calculate the raw meta data and return it. This must be called before the set is committed
|
|
|
|
// Entries modified only as a result of building the transaction metadata
|
|
boost::unordered_map<uint256, SLE::pointer> newMod;
|
|
|
|
typedef std::map<uint256, LedgerEntrySetEntry>::value_type u256_LES_pair;
|
|
BOOST_FOREACH (u256_LES_pair & it, mEntries)
|
|
{
|
|
SField::ptr type = &sfGeneric;
|
|
|
|
switch (it.second.mAction)
|
|
{
|
|
case taaMODIFY:
|
|
#ifdef META_DEBUG
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "Modified Node " << it.first;
|
|
#endif
|
|
type = &sfModifiedNode;
|
|
break;
|
|
|
|
case taaDELETE:
|
|
#ifdef META_DEBUG
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "Deleted Node " << it.first;
|
|
#endif
|
|
type = &sfDeletedNode;
|
|
break;
|
|
|
|
case taaCREATE:
|
|
#ifdef META_DEBUG
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "Created Node " << it.first;
|
|
#endif
|
|
type = &sfCreatedNode;
|
|
break;
|
|
|
|
default: // ignore these
|
|
break;
|
|
}
|
|
|
|
if (type == &sfGeneric)
|
|
continue;
|
|
|
|
SLE::pointer origNode = mLedger->getSLEi (it.first);
|
|
SLE::pointer curNode = it.second.mEntry;
|
|
|
|
if ((type == &sfModifiedNode) && (*curNode == *origNode))
|
|
continue;
|
|
|
|
uint16 nodeType = curNode ? curNode->getFieldU16 (sfLedgerEntryType) : origNode->getFieldU16 (sfLedgerEntryType);
|
|
|
|
mSet.setAffectedNode (it.first, *type, nodeType);
|
|
|
|
if (type == &sfDeletedNode)
|
|
{
|
|
assert (origNode && curNode);
|
|
threadOwners (origNode, mLedger, newMod); // thread transaction to owners
|
|
|
|
STObject prevs (sfPreviousFields);
|
|
BOOST_FOREACH (const SerializedType & obj, *origNode)
|
|
{
|
|
// go through the original node for modified fields saved on modification
|
|
if (obj.getFName ().shouldMeta (SField::sMD_ChangeOrig) && !curNode->hasMatchingEntry (obj))
|
|
prevs.addObject (obj);
|
|
}
|
|
|
|
if (!prevs.empty ())
|
|
mSet.getAffectedNode (it.first).addObject (prevs);
|
|
|
|
STObject finals (sfFinalFields);
|
|
BOOST_FOREACH (const SerializedType & obj, *curNode)
|
|
{
|
|
// go through the final node for final fields
|
|
if (obj.getFName ().shouldMeta (SField::sMD_Always | SField::sMD_DeleteFinal))
|
|
finals.addObject (obj);
|
|
}
|
|
|
|
if (!finals.empty ())
|
|
mSet.getAffectedNode (it.first).addObject (finals);
|
|
}
|
|
else if (type == &sfModifiedNode)
|
|
{
|
|
assert (curNode && origNode);
|
|
|
|
if (curNode->isThreadedType ()) // thread transaction to node it modified
|
|
threadTx (curNode, mLedger, newMod);
|
|
|
|
STObject prevs (sfPreviousFields);
|
|
BOOST_FOREACH (const SerializedType & obj, *origNode)
|
|
{
|
|
// search the original node for values saved on modify
|
|
if (obj.getFName ().shouldMeta (SField::sMD_ChangeOrig) && !curNode->hasMatchingEntry (obj))
|
|
prevs.addObject (obj);
|
|
}
|
|
|
|
if (!prevs.empty ())
|
|
mSet.getAffectedNode (it.first).addObject (prevs);
|
|
|
|
STObject finals (sfFinalFields);
|
|
BOOST_FOREACH (const SerializedType & obj, *curNode)
|
|
{
|
|
// search the final node for values saved always
|
|
if (obj.getFName ().shouldMeta (SField::sMD_Always | SField::sMD_ChangeNew))
|
|
finals.addObject (obj);
|
|
}
|
|
|
|
if (!finals.empty ())
|
|
mSet.getAffectedNode (it.first).addObject (finals);
|
|
}
|
|
else if (type == &sfCreatedNode) // if created, thread to owner(s)
|
|
{
|
|
assert (curNode && !origNode);
|
|
threadOwners (curNode, mLedger, newMod);
|
|
|
|
if (curNode->isThreadedType ()) // always thread to self
|
|
threadTx (curNode, mLedger, newMod);
|
|
|
|
STObject news (sfNewFields);
|
|
BOOST_FOREACH (const SerializedType & obj, *curNode)
|
|
{
|
|
// save non-default values
|
|
if (!obj.isDefault () && obj.getFName ().shouldMeta (SField::sMD_Create | SField::sMD_Always))
|
|
news.addObject (obj);
|
|
}
|
|
|
|
if (!news.empty ())
|
|
mSet.getAffectedNode (it.first).addObject (news);
|
|
}
|
|
else assert (false);
|
|
}
|
|
|
|
// add any new modified nodes to the modification set
|
|
typedef std::map<uint256, SLE::pointer>::value_type u256_sle_pair;
|
|
BOOST_FOREACH (u256_sle_pair & it, newMod)
|
|
entryModify (it.second);
|
|
|
|
mSet.addRaw (s, result, index);
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "Metadata:" << mSet.getJson (0);
|
|
}
|
|
|
|
TER LedgerEntrySet::dirCount (uint256 const& uRootIndex, uint32& uCount)
|
|
{
|
|
uint64 uNodeDir = 0;
|
|
|
|
uCount = 0;
|
|
|
|
do
|
|
{
|
|
SLE::pointer sleNode = entryCache (ltDIR_NODE, Ledger::getDirNodeIndex (uRootIndex, uNodeDir));
|
|
|
|
if (sleNode)
|
|
{
|
|
uCount += sleNode->getFieldV256 (sfIndexes).peekValue ().size ();
|
|
|
|
uNodeDir = sleNode->getFieldU64 (sfIndexNext); // Get next node.
|
|
}
|
|
else if (uNodeDir)
|
|
{
|
|
WriteLog (lsWARNING, LedgerEntrySet) << "dirCount: no such node";
|
|
|
|
assert (false);
|
|
|
|
return tefBAD_LEDGER;
|
|
}
|
|
}
|
|
while (uNodeDir);
|
|
|
|
return tesSUCCESS;
|
|
}
|
|
|
|
// <-- uNodeDir: For deletion, present to make dirDelete efficient.
|
|
// --> uRootIndex: The index of the base of the directory. Nodes are based off of this.
|
|
// --> uLedgerIndex: Value to add to directory.
|
|
// Only append. This allow for things that watch append only structure to just monitor from the last node on ward.
|
|
// Within a node with no deletions order of elements is sequential. Otherwise, order of elements is random.
|
|
TER LedgerEntrySet::dirAdd (
|
|
uint64& uNodeDir,
|
|
uint256 const& uRootIndex,
|
|
uint256 const& uLedgerIndex,
|
|
FUNCTION_TYPE<void (SLE::ref)> fDescriber)
|
|
{
|
|
WriteLog (lsTRACE, LedgerEntrySet) << boost::str (boost::format ("dirAdd: uRootIndex=%s uLedgerIndex=%s")
|
|
% uRootIndex.ToString ()
|
|
% uLedgerIndex.ToString ());
|
|
|
|
SLE::pointer sleNode;
|
|
STVector256 svIndexes;
|
|
SLE::pointer sleRoot = entryCache (ltDIR_NODE, uRootIndex);
|
|
|
|
if (!sleRoot)
|
|
{
|
|
// No root, make it.
|
|
sleRoot = entryCreate (ltDIR_NODE, uRootIndex);
|
|
sleRoot->setFieldH256 (sfRootIndex, uRootIndex);
|
|
fDescriber (sleRoot);
|
|
|
|
sleNode = sleRoot;
|
|
uNodeDir = 0;
|
|
}
|
|
else
|
|
{
|
|
uNodeDir = sleRoot->getFieldU64 (sfIndexPrevious); // Get index to last directory node.
|
|
|
|
if (uNodeDir)
|
|
{
|
|
// Try adding to last node.
|
|
sleNode = entryCache (ltDIR_NODE, Ledger::getDirNodeIndex (uRootIndex, uNodeDir));
|
|
|
|
assert (sleNode);
|
|
}
|
|
else
|
|
{
|
|
// Try adding to root. Didn't have a previous set to the last node.
|
|
sleNode = sleRoot;
|
|
}
|
|
|
|
svIndexes = sleNode->getFieldV256 (sfIndexes);
|
|
|
|
if (DIR_NODE_MAX != svIndexes.peekValue ().size ())
|
|
{
|
|
// Add to current node.
|
|
entryModify (sleNode);
|
|
}
|
|
// Add to new node.
|
|
else if (!++uNodeDir)
|
|
{
|
|
return tecDIR_FULL;
|
|
}
|
|
else
|
|
{
|
|
// Have old last point to new node
|
|
sleNode->setFieldU64 (sfIndexNext, uNodeDir);
|
|
entryModify (sleNode);
|
|
|
|
// Have root point to new node.
|
|
sleRoot->setFieldU64 (sfIndexPrevious, uNodeDir);
|
|
entryModify (sleRoot);
|
|
|
|
// Create the new node.
|
|
sleNode = entryCreate (ltDIR_NODE, Ledger::getDirNodeIndex (uRootIndex, uNodeDir));
|
|
sleNode->setFieldH256 (sfRootIndex, uRootIndex);
|
|
|
|
if (uNodeDir != 1)
|
|
sleNode->setFieldU64 (sfIndexPrevious, uNodeDir - 1);
|
|
|
|
fDescriber (sleNode);
|
|
|
|
svIndexes = STVector256 ();
|
|
}
|
|
}
|
|
|
|
svIndexes.peekValue ().push_back (uLedgerIndex); // Append entry.
|
|
sleNode->setFieldV256 (sfIndexes, svIndexes); // Save entry.
|
|
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "dirAdd: creating: root: " << uRootIndex.ToString ();
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "dirAdd: appending: Entry: " << uLedgerIndex.ToString ();
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "dirAdd: appending: Node: " << strHex (uNodeDir);
|
|
// WriteLog (lsINFO, LedgerEntrySet) << "dirAdd: appending: PREV: " << svIndexes.peekValue()[0].ToString();
|
|
|
|
return tesSUCCESS;
|
|
}
|
|
|
|
// Ledger must be in a state for this to work.
|
|
TER LedgerEntrySet::dirDelete (
|
|
const bool bKeepRoot, // --> True, if we never completely clean up, after we overflow the root node.
|
|
const uint64& uNodeDir, // --> Node containing entry.
|
|
uint256 const& uRootIndex, // --> The index of the base of the directory. Nodes are based off of this.
|
|
uint256 const& uLedgerIndex, // --> Value to remove from directory.
|
|
const bool bStable, // --> True, not to change relative order of entries.
|
|
const bool bSoft) // --> True, uNodeDir is not hard and fast (pass uNodeDir=0).
|
|
{
|
|
uint64 uNodeCur = uNodeDir;
|
|
SLE::pointer sleNode = entryCache (ltDIR_NODE, uNodeCur ? Ledger::getDirNodeIndex (uRootIndex, uNodeCur) : uRootIndex);
|
|
|
|
if (!sleNode)
|
|
{
|
|
WriteLog (lsWARNING, LedgerEntrySet)
|
|
<< boost::str (boost::format ("dirDelete: no such node: uRootIndex=%s uNodeDir=%s uLedgerIndex=%s")
|
|
% uRootIndex.ToString ()
|
|
% strHex (uNodeDir)
|
|
% uLedgerIndex.ToString ());
|
|
|
|
if (!bSoft)
|
|
{
|
|
assert (false);
|
|
return tefBAD_LEDGER;
|
|
}
|
|
else if (uNodeDir < 20)
|
|
{
|
|
// Go the extra mile. Even if node doesn't exist, try the next node.
|
|
|
|
return dirDelete (bKeepRoot, uNodeDir + 1, uRootIndex, uLedgerIndex, bStable, true);
|
|
}
|
|
else
|
|
{
|
|
return tefBAD_LEDGER;
|
|
}
|
|
}
|
|
|
|
STVector256 svIndexes = sleNode->getFieldV256 (sfIndexes);
|
|
std::vector<uint256>& vuiIndexes = svIndexes.peekValue ();
|
|
std::vector<uint256>::iterator it;
|
|
|
|
it = std::find (vuiIndexes.begin (), vuiIndexes.end (), uLedgerIndex);
|
|
|
|
if (vuiIndexes.end () == it)
|
|
{
|
|
if (!bSoft)
|
|
{
|
|
assert (false);
|
|
|
|
WriteLog (lsWARNING, LedgerEntrySet) << "dirDelete: no such entry";
|
|
|
|
return tefBAD_LEDGER;
|
|
}
|
|
else if (uNodeDir < 20)
|
|
{
|
|
// Go the extra mile. Even if entry not in node, try the next node.
|
|
|
|
return dirDelete (bKeepRoot, uNodeDir + 1, uRootIndex, uLedgerIndex, bStable, true);
|
|
}
|
|
else
|
|
{
|
|
return tefBAD_LEDGER;
|
|
}
|
|
}
|
|
|
|
// Remove the element.
|
|
if (vuiIndexes.size () > 1)
|
|
{
|
|
if (bStable)
|
|
{
|
|
vuiIndexes.erase (it);
|
|
}
|
|
else
|
|
{
|
|
*it = vuiIndexes[vuiIndexes.size () - 1];
|
|
vuiIndexes.resize (vuiIndexes.size () - 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vuiIndexes.clear ();
|
|
}
|
|
|
|
sleNode->setFieldV256 (sfIndexes, svIndexes);
|
|
entryModify (sleNode);
|
|
|
|
if (vuiIndexes.empty ())
|
|
{
|
|
// May be able to delete nodes.
|
|
uint64 uNodePrevious = sleNode->getFieldU64 (sfIndexPrevious);
|
|
uint64 uNodeNext = sleNode->getFieldU64 (sfIndexNext);
|
|
|
|
if (!uNodeCur)
|
|
{
|
|
// Just emptied root node.
|
|
|
|
if (!uNodePrevious)
|
|
{
|
|
// Never overflowed the root node. Delete it.
|
|
entryDelete (sleNode);
|
|
}
|
|
// Root overflowed.
|
|
else if (bKeepRoot)
|
|
{
|
|
// If root overflowed and not allowed to delete overflowed root node.
|
|
|
|
nothing ();
|
|
}
|
|
else if (uNodePrevious != uNodeNext)
|
|
{
|
|
// Have more than 2 nodes. Can't delete root node.
|
|
|
|
nothing ();
|
|
}
|
|
else
|
|
{
|
|
// Have only a root node and a last node.
|
|
SLE::pointer sleLast = entryCache (ltDIR_NODE, Ledger::getDirNodeIndex (uRootIndex, uNodeNext));
|
|
|
|
assert (sleLast);
|
|
|
|
if (sleLast->getFieldV256 (sfIndexes).peekValue ().empty ())
|
|
{
|
|
// Both nodes are empty.
|
|
|
|
entryDelete (sleNode); // Delete root.
|
|
entryDelete (sleLast); // Delete last.
|
|
}
|
|
else
|
|
{
|
|
// Have an entry, can't delete root node.
|
|
|
|
nothing ();
|
|
}
|
|
}
|
|
}
|
|
// Just emptied a non-root node.
|
|
else if (uNodeNext)
|
|
{
|
|
// Not root and not last node. Can delete node.
|
|
|
|
SLE::pointer slePrevious = entryCache (ltDIR_NODE, uNodePrevious ? Ledger::getDirNodeIndex (uRootIndex, uNodePrevious) : uRootIndex);
|
|
|
|
assert (slePrevious);
|
|
|
|
SLE::pointer sleNext = entryCache (ltDIR_NODE, uNodeNext ? Ledger::getDirNodeIndex (uRootIndex, uNodeNext) : uRootIndex);
|
|
|
|
assert (slePrevious);
|
|
assert (sleNext);
|
|
|
|
if (!slePrevious)
|
|
{
|
|
WriteLog (lsWARNING, LedgerEntrySet) << "dirDelete: previous node is missing";
|
|
|
|
return tefBAD_LEDGER;
|
|
}
|
|
|
|
if (!sleNext)
|
|
{
|
|
WriteLog (lsWARNING, LedgerEntrySet) << "dirDelete: next node is missing";
|
|
|
|
return tefBAD_LEDGER;
|
|
}
|
|
|
|
// Fix previous to point to its new next.
|
|
slePrevious->setFieldU64 (sfIndexNext, uNodeNext);
|
|
entryModify (slePrevious);
|
|
|
|
// Fix next to point to its new previous.
|
|
sleNext->setFieldU64 (sfIndexPrevious, uNodePrevious);
|
|
entryModify (sleNext);
|
|
|
|
entryDelete(sleNode);
|
|
}
|
|
// Last node.
|
|
else if (bKeepRoot || uNodePrevious)
|
|
{
|
|
// Not allowed to delete last node as root was overflowed.
|
|
// Or, have pervious entries preventing complete delete.
|
|
|
|
nothing ();
|
|
}
|
|
else
|
|
{
|
|
// Last and only node besides the root.
|
|
SLE::pointer sleRoot = entryCache (ltDIR_NODE, uRootIndex);
|
|
|
|
assert (sleRoot);
|
|
|
|
if (sleRoot->getFieldV256 (sfIndexes).peekValue ().empty ())
|
|
{
|
|
// Both nodes are empty.
|
|
|
|
entryDelete (sleRoot); // Delete root.
|
|
entryDelete (sleNode); // Delete last.
|
|
}
|
|
else
|
|
{
|
|
// Root has an entry, can't delete.
|
|
|
|
nothing ();
|
|
}
|
|
}
|
|
}
|
|
|
|
return tesSUCCESS;
|
|
}
|
|
|
|
// Return the first entry and advance uDirEntry.
|
|
// <-- true, if had a next entry.
|
|
bool LedgerEntrySet::dirFirst (
|
|
uint256 const& uRootIndex, // --> Root of directory.
|
|
SLE::pointer& sleNode, // <-- current node
|
|
unsigned int& uDirEntry, // <-- next entry
|
|
uint256& uEntryIndex) // <-- The entry, if available. Otherwise, zero.
|
|
{
|
|
sleNode = entryCache (ltDIR_NODE, uRootIndex);
|
|
uDirEntry = 0;
|
|
|
|
assert (sleNode); // Never probe for directories.
|
|
|
|
return LedgerEntrySet::dirNext (uRootIndex, sleNode, uDirEntry, uEntryIndex);
|
|
}
|
|
|
|
// Return the current entry and advance uDirEntry.
|
|
// <-- true, if had a next entry.
|
|
bool LedgerEntrySet::dirNext (
|
|
uint256 const& uRootIndex, // --> Root of directory
|
|
SLE::pointer& sleNode, // <-> current node
|
|
unsigned int& uDirEntry, // <-> next entry
|
|
uint256& uEntryIndex) // <-- The entry, if available. Otherwise, zero.
|
|
{
|
|
STVector256 svIndexes = sleNode->getFieldV256 (sfIndexes);
|
|
std::vector<uint256>& vuiIndexes = svIndexes.peekValue ();
|
|
|
|
assert (uDirEntry <= vuiIndexes.size ());
|
|
|
|
if (uDirEntry >= vuiIndexes.size ())
|
|
{
|
|
uint64 uNodeNext = sleNode->getFieldU64 (sfIndexNext);
|
|
|
|
if (!uNodeNext)
|
|
{
|
|
uEntryIndex.zero ();
|
|
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
SLE::pointer sleNext = entryCache (ltDIR_NODE, Ledger::getDirNodeIndex (uRootIndex, uNodeNext));
|
|
uDirEntry = 0;
|
|
|
|
if (!sleNext)
|
|
{ // This should never happen
|
|
WriteLog (lsFATAL, LedgerEntrySet) << "Corrupt directory: index:" << uRootIndex << " next:" << uNodeNext;
|
|
return false;
|
|
}
|
|
|
|
sleNode = sleNext;
|
|
return dirNext (uRootIndex, sleNode, uDirEntry, uEntryIndex);
|
|
}
|
|
}
|
|
|
|
uEntryIndex = vuiIndexes[uDirEntry++];
|
|
WriteLog (lsTRACE, LedgerEntrySet) << boost::str (boost::format ("dirNext: uDirEntry=%d uEntryIndex=%s") % uDirEntry % uEntryIndex);
|
|
|
|
return true;
|
|
}
|
|
|
|
uint256 LedgerEntrySet::getNextLedgerIndex (uint256 const& uHash)
|
|
{
|
|
// find next node in ledger that isn't deleted by LES
|
|
uint256 ledgerNext = uHash;
|
|
std::map<uint256, LedgerEntrySetEntry>::const_iterator it;
|
|
|
|
do
|
|
{
|
|
ledgerNext = mLedger->getNextLedgerIndex (ledgerNext);
|
|
it = mEntries.find (ledgerNext);
|
|
}
|
|
while ((it != mEntries.end ()) && (it->second.mAction == taaDELETE));
|
|
|
|
// find next node in LES that isn't deleted
|
|
for (it = mEntries.upper_bound (uHash); it != mEntries.end (); ++it)
|
|
{
|
|
// node found in LES, node found in ledger, return earliest
|
|
if (it->second.mAction != taaDELETE)
|
|
return (ledgerNext.isNonZero () && (ledgerNext < it->first)) ? ledgerNext : it->first;
|
|
}
|
|
|
|
// nothing next in LES, return next ledger node
|
|
return ledgerNext;
|
|
}
|
|
|
|
uint256 LedgerEntrySet::getNextLedgerIndex (uint256 const& uHash, uint256 const& uEnd)
|
|
{
|
|
uint256 next = getNextLedgerIndex (uHash);
|
|
|
|
if (next > uEnd)
|
|
return uint256 ();
|
|
|
|
return next;
|
|
}
|
|
|
|
// If there is a count, adjust the owner count by iAmount. Otherwise, compute the owner count and store it.
|
|
void LedgerEntrySet::ownerCountAdjust (const uint160& uOwnerID, int iAmount, SLE::ref sleAccountRoot)
|
|
{
|
|
SLE::pointer sleHold = sleAccountRoot
|
|
? SLE::pointer ()
|
|
: entryCache (ltACCOUNT_ROOT, Ledger::getAccountRootIndex (uOwnerID));
|
|
|
|
SLE::ref sleRoot = sleAccountRoot
|
|
? sleAccountRoot
|
|
: sleHold;
|
|
|
|
const uint32 uOwnerCount = sleRoot->getFieldU32 (sfOwnerCount);
|
|
|
|
const uint32 uNew = iAmount + int (uOwnerCount) > 0
|
|
? uOwnerCount + iAmount
|
|
: 0;
|
|
|
|
if (uOwnerCount != uNew)
|
|
{
|
|
sleRoot->setFieldU32 (sfOwnerCount, uOwnerCount + iAmount);
|
|
entryModify (sleRoot);
|
|
}
|
|
}
|
|
|
|
TER LedgerEntrySet::offerDelete (SLE::ref sleOffer, uint256 const& uOfferIndex, const uint160& uOwnerID)
|
|
{
|
|
bool bOwnerNode = sleOffer->isFieldPresent (sfOwnerNode); // Detect legacy dirs.
|
|
uint64 uOwnerNode = sleOffer->getFieldU64 (sfOwnerNode);
|
|
TER terResult = dirDelete (false, uOwnerNode, Ledger::getOwnerDirIndex (uOwnerID), uOfferIndex, false, !bOwnerNode);
|
|
|
|
if (tesSUCCESS == terResult)
|
|
{
|
|
ownerCountAdjust (uOwnerID, -1);
|
|
|
|
uint256 uDirectory = sleOffer->getFieldH256 (sfBookDirectory);
|
|
uint64 uBookNode = sleOffer->getFieldU64 (sfBookNode);
|
|
|
|
// Offer delete is always hard. Always have hints.
|
|
terResult = dirDelete (false, uBookNode, uDirectory, uOfferIndex, true, true);
|
|
}
|
|
|
|
entryDelete (sleOffer);
|
|
|
|
return terResult;
|
|
}
|
|
|
|
TER LedgerEntrySet::offerDelete (uint256 const& uOfferIndex)
|
|
{
|
|
SLE::pointer sleOffer = entryCache (ltOFFER, uOfferIndex);
|
|
|
|
if (!sleOffer)
|
|
return tesSUCCESS;
|
|
|
|
const uint160 uOwnerID = sleOffer->getFieldAccount160 (sfAccount);
|
|
return offerDelete (sleOffer, uOfferIndex, uOwnerID);
|
|
}
|
|
|
|
// Returns amount owed by uToAccountID to uFromAccountID.
|
|
// <-- $owed/uCurrencyID/uToAccountID: positive: uFromAccountID holds IOUs., negative: uFromAccountID owes IOUs.
|
|
STAmount LedgerEntrySet::rippleOwed (const uint160& uToAccountID, const uint160& uFromAccountID, const uint160& uCurrencyID)
|
|
{
|
|
STAmount saBalance;
|
|
SLE::pointer sleRippleState = entryCache (ltRIPPLE_STATE, Ledger::getRippleStateIndex (uToAccountID, uFromAccountID, uCurrencyID));
|
|
|
|
if (sleRippleState)
|
|
{
|
|
saBalance = sleRippleState->getFieldAmount (sfBalance);
|
|
|
|
if (uToAccountID < uFromAccountID)
|
|
saBalance.negate ();
|
|
|
|
saBalance.setIssuer (uToAccountID);
|
|
}
|
|
else
|
|
{
|
|
saBalance.zero (uCurrencyID, uToAccountID);
|
|
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << "rippleOwed: No credit line between "
|
|
<< RippleAddress::createHumanAccountID (uFromAccountID)
|
|
<< " and "
|
|
<< RippleAddress::createHumanAccountID (uToAccountID)
|
|
<< " for "
|
|
<< STAmount::createHumanCurrency (uCurrencyID)
|
|
<< "." ;
|
|
#if 0
|
|
// We could cut off coming here if we test for no line sooner.
|
|
|
|
assert (false);
|
|
#endif
|
|
}
|
|
|
|
return saBalance;
|
|
}
|
|
|
|
// Maximum amount of IOUs uToAccountID will hold from uFromAccountID.
|
|
// <-- $amount/uCurrencyID/uToAccountID.
|
|
STAmount LedgerEntrySet::rippleLimit (const uint160& uToAccountID, const uint160& uFromAccountID, const uint160& uCurrencyID)
|
|
{
|
|
STAmount saLimit;
|
|
SLE::pointer sleRippleState = entryCache (ltRIPPLE_STATE, Ledger::getRippleStateIndex (uToAccountID, uFromAccountID, uCurrencyID));
|
|
|
|
if (sleRippleState)
|
|
{
|
|
saLimit = sleRippleState->getFieldAmount (uToAccountID < uFromAccountID ? sfLowLimit : sfHighLimit);
|
|
saLimit.setIssuer (uToAccountID);
|
|
}
|
|
else
|
|
{
|
|
saLimit.zero (uCurrencyID, uToAccountID);
|
|
#if 0
|
|
// We could cut off coming here if we test for no line sooner.
|
|
assert (false);
|
|
#endif
|
|
}
|
|
|
|
return saLimit;
|
|
|
|
}
|
|
|
|
uint32 LedgerEntrySet::rippleTransferRate (const uint160& uIssuerID)
|
|
{
|
|
SLE::pointer sleAccount = entryCache (ltACCOUNT_ROOT, Ledger::getAccountRootIndex (uIssuerID));
|
|
|
|
uint32 uQuality = sleAccount && sleAccount->isFieldPresent (sfTransferRate)
|
|
? sleAccount->getFieldU32 (sfTransferRate)
|
|
: QUALITY_ONE;
|
|
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << boost::str (boost::format ("rippleTransferRate: uIssuerID=%s account_exists=%d transfer_rate=%f")
|
|
% RippleAddress::createHumanAccountID (uIssuerID)
|
|
% !!sleAccount
|
|
% (uQuality / 1000000000.0));
|
|
|
|
return uQuality;
|
|
}
|
|
|
|
uint32 LedgerEntrySet::rippleTransferRate (const uint160& uSenderID, const uint160& uReceiverID, const uint160& uIssuerID)
|
|
{
|
|
return uSenderID == uIssuerID || uReceiverID == uIssuerID
|
|
? QUALITY_ONE
|
|
: rippleTransferRate (uIssuerID);
|
|
}
|
|
|
|
// XXX Might not need this, might store in nodes on calc reverse.
|
|
uint32 LedgerEntrySet::rippleQualityIn (const uint160& uToAccountID, const uint160& uFromAccountID, const uint160& uCurrencyID, SField::ref sfLow, SField::ref sfHigh)
|
|
{
|
|
uint32 uQuality = QUALITY_ONE;
|
|
SLE::pointer sleRippleState;
|
|
|
|
if (uToAccountID == uFromAccountID)
|
|
{
|
|
nothing ();
|
|
}
|
|
else
|
|
{
|
|
sleRippleState = entryCache (ltRIPPLE_STATE, Ledger::getRippleStateIndex (uToAccountID, uFromAccountID, uCurrencyID));
|
|
|
|
if (sleRippleState)
|
|
{
|
|
SField::ref sfField = uToAccountID < uFromAccountID ? sfLow : sfHigh;
|
|
|
|
uQuality = sleRippleState->isFieldPresent (sfField)
|
|
? sleRippleState->getFieldU32 (sfField)
|
|
: QUALITY_ONE;
|
|
|
|
if (!uQuality)
|
|
uQuality = 1; // Avoid divide by zero.
|
|
}
|
|
else
|
|
{
|
|
// XXX Ideally, catch no before this. So we can assert to be stricter.
|
|
uQuality = QUALITY_ONE;
|
|
}
|
|
}
|
|
|
|
WriteLog (lsTRACE, LedgerEntrySet) << boost::str (boost::format ("rippleQuality: %s uToAccountID=%s uFromAccountID=%s uCurrencyID=%s bLine=%d uQuality=%f")
|
|
% (sfLow == sfLowQualityIn ? "in" : "out")
|
|
% RippleAddress::createHumanAccountID (uToAccountID)
|
|
% RippleAddress::createHumanAccountID (uFromAccountID)
|
|
% STAmount::createHumanCurrency (uCurrencyID)
|
|
% !!sleRippleState
|
|
% (uQuality / 1000000000.0));
|
|
|
|
// assert(uToAccountID == uFromAccountID || !!sleRippleState);
|
|
|
|
return uQuality;
|
|
}
|
|
|
|
// Return how much of uIssuerID's uCurrencyID IOUs that uAccountID holds. May be negative.
|
|
// <-- IOU's uAccountID has of uIssuerID.
|
|
STAmount LedgerEntrySet::rippleHolds (const uint160& uAccountID, const uint160& uCurrencyID, const uint160& uIssuerID)
|
|
{
|
|
STAmount saBalance;
|
|
SLE::pointer sleRippleState = entryCache (ltRIPPLE_STATE, Ledger::getRippleStateIndex (uAccountID, uIssuerID, uCurrencyID));
|
|
|
|
if (!sleRippleState)
|
|
{
|
|
saBalance.zero (uCurrencyID, uIssuerID);
|
|
}
|
|
else if (uAccountID > uIssuerID)
|
|
{
|
|
saBalance = sleRippleState->getFieldAmount (sfBalance);
|
|
saBalance.negate (); // Put balance in uAccountID terms.
|
|
|
|
saBalance.setIssuer (uIssuerID);
|
|
}
|
|
else
|
|
{
|
|
saBalance = sleRippleState->getFieldAmount (sfBalance);
|
|
|
|
saBalance.setIssuer (uIssuerID);
|
|
}
|
|
|
|
return saBalance;
|
|
}
|
|
|
|
// Returns the amount an account can spend without going into debt.
|
|
//
|
|
// <-- saAmount: amount of uCurrencyID held by uAccountID. May be negative.
|
|
STAmount LedgerEntrySet::accountHolds (const uint160& uAccountID, const uint160& uCurrencyID, const uint160& uIssuerID)
|
|
{
|
|
STAmount saAmount;
|
|
|
|
if (!uCurrencyID)
|
|
{
|
|
SLE::pointer sleAccount = entryCache (ltACCOUNT_ROOT, Ledger::getAccountRootIndex (uAccountID));
|
|
uint64 uReserve = mLedger->getReserve (sleAccount->getFieldU32 (sfOwnerCount));
|
|
|
|
STAmount saBalance = sleAccount->getFieldAmount (sfBalance);
|
|
|
|
if (saBalance < uReserve)
|
|
{
|
|
saAmount.zero ();
|
|
}
|
|
else
|
|
{
|
|
saAmount = saBalance - uReserve;
|
|
}
|
|
|
|
WriteLog (lsTRACE, LedgerEntrySet) << boost::str (boost::format ("accountHolds: uAccountID=%s saAmount=%s saBalance=%s uReserve=%d")
|
|
% RippleAddress::createHumanAccountID (uAccountID)
|
|
% saAmount.getFullText ()
|
|
% saBalance.getFullText ()
|
|
% uReserve);
|
|
}
|
|
else
|
|
{
|
|
saAmount = rippleHolds (uAccountID, uCurrencyID, uIssuerID);
|
|
|
|
WriteLog (lsTRACE, LedgerEntrySet) << boost::str (boost::format ("accountHolds: uAccountID=%s saAmount=%s")
|
|
% RippleAddress::createHumanAccountID (uAccountID)
|
|
% saAmount.getFullText ());
|
|
}
|
|
|
|
return saAmount;
|
|
}
|
|
|
|
// Returns the funds available for uAccountID for a currency/issuer.
|
|
// Use when you need a default for rippling uAccountID's currency.
|
|
// XXX Should take into account quality?
|
|
// --> saDefault/currency/issuer
|
|
// <-- saFunds: Funds available. May be negative.
|
|
// If the issuer is the same as uAccountID, funds are unlimited, use result is saDefault.
|
|
STAmount LedgerEntrySet::accountFunds (const uint160& uAccountID, const STAmount& saDefault)
|
|
{
|
|
STAmount saFunds;
|
|
|
|
if (!saDefault.isNative () && saDefault.getIssuer () == uAccountID)
|
|
{
|
|
saFunds = saDefault;
|
|
|
|
WriteLog (lsTRACE, LedgerEntrySet) << boost::str (boost::format ("accountFunds: uAccountID=%s saDefault=%s SELF-FUNDED")
|
|
% RippleAddress::createHumanAccountID (uAccountID)
|
|
% saDefault.getFullText ());
|
|
}
|
|
else
|
|
{
|
|
saFunds = accountHolds (uAccountID, saDefault.getCurrency (), saDefault.getIssuer ());
|
|
|
|
WriteLog (lsTRACE, LedgerEntrySet) << boost::str (boost::format ("accountFunds: uAccountID=%s saDefault=%s saFunds=%s")
|
|
% RippleAddress::createHumanAccountID (uAccountID)
|
|
% saDefault.getFullText ()
|
|
% saFunds.getFullText ());
|
|
}
|
|
|
|
return saFunds;
|
|
}
|
|
|
|
// Calculate transit fee.
|
|
STAmount LedgerEntrySet::rippleTransferFee (const uint160& uSenderID, const uint160& uReceiverID, const uint160& uIssuerID, const STAmount& saAmount)
|
|
{
|
|
if (uSenderID != uIssuerID && uReceiverID != uIssuerID)
|
|
{
|
|
uint32 uTransitRate = rippleTransferRate (uIssuerID);
|
|
|
|
if (QUALITY_ONE != uTransitRate)
|
|
{
|
|
STAmount saTransitRate (CURRENCY_ONE, ACCOUNT_ONE, static_cast<uint64> (uTransitRate), -9);
|
|
|
|
STAmount saTransferTotal = STAmount::multiply (saAmount, saTransitRate, saAmount.getCurrency (), saAmount.getIssuer ());
|
|
STAmount saTransferFee = saTransferTotal - saAmount;
|
|
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << boost::str (boost::format ("rippleTransferFee: saTransferFee=%s")
|
|
% saTransferFee.getFullText ());
|
|
|
|
return saTransferFee;
|
|
}
|
|
}
|
|
|
|
return STAmount (saAmount.getCurrency (), saAmount.getIssuer ());
|
|
}
|
|
|
|
TER LedgerEntrySet::trustCreate (
|
|
const bool bSrcHigh,
|
|
const uint160& uSrcAccountID,
|
|
const uint160& uDstAccountID,
|
|
uint256 const& uIndex, // --> ripple state entry
|
|
SLE::ref sleAccount, // --> the account being set.
|
|
const bool bAuth, // --> authorize account.
|
|
const STAmount& saBalance, // --> balance of account being set. Issuer should be ACCOUNT_ONE
|
|
const STAmount& saLimit, // --> limit for account being set. Issuer should be the account being set.
|
|
const uint32 uQualityIn,
|
|
const uint32 uQualityOut)
|
|
{
|
|
const uint160& uLowAccountID = !bSrcHigh ? uSrcAccountID : uDstAccountID;
|
|
const uint160& uHighAccountID = bSrcHigh ? uSrcAccountID : uDstAccountID;
|
|
|
|
SLE::pointer sleRippleState = entryCreate (ltRIPPLE_STATE, uIndex);
|
|
|
|
uint64 uLowNode;
|
|
uint64 uHighNode;
|
|
|
|
TER terResult = dirAdd (
|
|
uLowNode,
|
|
Ledger::getOwnerDirIndex (uLowAccountID),
|
|
sleRippleState->getIndex (),
|
|
BIND_TYPE (&Ledger::ownerDirDescriber, P_1, uLowAccountID));
|
|
|
|
if (tesSUCCESS == terResult)
|
|
{
|
|
terResult = dirAdd (
|
|
uHighNode,
|
|
Ledger::getOwnerDirIndex (uHighAccountID),
|
|
sleRippleState->getIndex (),
|
|
BIND_TYPE (&Ledger::ownerDirDescriber, P_1, uHighAccountID));
|
|
}
|
|
|
|
if (tesSUCCESS == terResult)
|
|
{
|
|
const bool bSetDst = saLimit.getIssuer () == uDstAccountID;
|
|
const bool bSetHigh = bSrcHigh ^ bSetDst;
|
|
|
|
sleRippleState->setFieldU64 (sfLowNode, uLowNode); // Remember deletion hints.
|
|
sleRippleState->setFieldU64 (sfHighNode, uHighNode);
|
|
|
|
sleRippleState->setFieldAmount (!bSetHigh ? sfLowLimit : sfHighLimit, saLimit);
|
|
sleRippleState->setFieldAmount ( bSetHigh ? sfLowLimit : sfHighLimit, STAmount (saBalance.getCurrency (), bSetDst ? uSrcAccountID : uDstAccountID));
|
|
|
|
if (uQualityIn)
|
|
sleRippleState->setFieldU32 (!bSetHigh ? sfLowQualityIn : sfHighQualityIn, uQualityIn);
|
|
|
|
if (uQualityOut)
|
|
sleRippleState->setFieldU32 (!bSetHigh ? sfLowQualityOut : sfHighQualityOut, uQualityOut);
|
|
|
|
uint32 uFlags = !bSetHigh ? lsfLowReserve : lsfHighReserve;
|
|
|
|
if (bAuth)
|
|
{
|
|
uFlags |= (!bSetHigh ? lsfLowAuth : lsfHighAuth);
|
|
}
|
|
|
|
sleRippleState->setFieldU32 (sfFlags, uFlags);
|
|
|
|
ownerCountAdjust (!bSetDst ? uSrcAccountID : uDstAccountID, 1, sleAccount);
|
|
|
|
sleRippleState->setFieldAmount (sfBalance, bSetHigh ? -saBalance : saBalance); // ONLY: Create ripple balance.
|
|
}
|
|
|
|
return terResult;
|
|
}
|
|
|
|
TER LedgerEntrySet::trustDelete (SLE::ref sleRippleState, const uint160& uLowAccountID, const uint160& uHighAccountID)
|
|
{
|
|
bool bLowNode = sleRippleState->isFieldPresent (sfLowNode); // Detect legacy dirs.
|
|
bool bHighNode = sleRippleState->isFieldPresent (sfHighNode);
|
|
uint64 uLowNode = sleRippleState->getFieldU64 (sfLowNode);
|
|
uint64 uHighNode = sleRippleState->getFieldU64 (sfHighNode);
|
|
TER terResult;
|
|
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "trustDelete: Deleting ripple line: low";
|
|
terResult = dirDelete (false, uLowNode, Ledger::getOwnerDirIndex (uLowAccountID), sleRippleState->getIndex (), false, !bLowNode);
|
|
|
|
if (tesSUCCESS == terResult)
|
|
{
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "trustDelete: Deleting ripple line: high";
|
|
terResult = dirDelete (false, uHighNode, Ledger::getOwnerDirIndex (uHighAccountID), sleRippleState->getIndex (), false, !bHighNode);
|
|
}
|
|
|
|
WriteLog (lsTRACE, LedgerEntrySet) << "trustDelete: Deleting ripple line: state";
|
|
entryDelete (sleRippleState);
|
|
|
|
return terResult;
|
|
}
|
|
|
|
// Direct send w/o fees:
|
|
// - Redeeming IOUs and/or sending sender's own IOUs.
|
|
// - Create trust line of needed.
|
|
// --> bCheckIssuer : normally require issuer to be involved.
|
|
TER LedgerEntrySet::rippleCredit (const uint160& uSenderID, const uint160& uReceiverID, const STAmount& saAmount, bool bCheckIssuer)
|
|
{
|
|
uint160 uIssuerID = saAmount.getIssuer ();
|
|
uint160 uCurrencyID = saAmount.getCurrency ();
|
|
|
|
// Make sure issuer is involved.
|
|
assert (!bCheckIssuer || uSenderID == uIssuerID || uReceiverID == uIssuerID);
|
|
|
|
// Disallow sending to self.
|
|
assert (uSenderID != uReceiverID);
|
|
|
|
bool bSenderHigh = uSenderID > uReceiverID;
|
|
uint256 uIndex = Ledger::getRippleStateIndex (uSenderID, uReceiverID, saAmount.getCurrency ());
|
|
SLE::pointer sleRippleState = entryCache (ltRIPPLE_STATE, uIndex);
|
|
|
|
TER terResult;
|
|
|
|
assert (!!uSenderID && uSenderID != ACCOUNT_ONE);
|
|
assert (!!uReceiverID && uReceiverID != ACCOUNT_ONE);
|
|
|
|
if (!sleRippleState)
|
|
{
|
|
STAmount saReceiverLimit = STAmount (uCurrencyID, uReceiverID);
|
|
STAmount saBalance = saAmount;
|
|
|
|
saBalance.setIssuer (ACCOUNT_ONE);
|
|
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << boost::str (boost::format ("rippleCredit: create line: %s --> %s : %s")
|
|
% RippleAddress::createHumanAccountID (uSenderID)
|
|
% RippleAddress::createHumanAccountID (uReceiverID)
|
|
% saAmount.getFullText ());
|
|
|
|
terResult = trustCreate (
|
|
bSenderHigh,
|
|
uSenderID,
|
|
uReceiverID,
|
|
uIndex,
|
|
entryCache (ltACCOUNT_ROOT, Ledger::getAccountRootIndex (uReceiverID)),
|
|
false,
|
|
saBalance,
|
|
saReceiverLimit);
|
|
}
|
|
else
|
|
{
|
|
STAmount saBalance = sleRippleState->getFieldAmount (sfBalance);
|
|
|
|
if (bSenderHigh)
|
|
saBalance.negate (); // Put balance in sender terms.
|
|
|
|
STAmount saBefore = saBalance;
|
|
|
|
saBalance -= saAmount;
|
|
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << boost::str (boost::format ("rippleCredit: %s --> %s : before=%s amount=%s after=%s")
|
|
% RippleAddress::createHumanAccountID (uSenderID)
|
|
% RippleAddress::createHumanAccountID (uReceiverID)
|
|
% saBefore.getFullText ()
|
|
% saAmount.getFullText ()
|
|
% saBalance.getFullText ());
|
|
|
|
bool bDelete = false;
|
|
uint32 uFlags;
|
|
|
|
// YYY Could skip this if rippling in reverse.
|
|
if (saBefore.isPositive () // Sender balance was positive.
|
|
&& !saBalance.isPositive () // Sender is zero or negative.
|
|
&& isSetBit ((uFlags = sleRippleState->getFieldU32 (sfFlags)), !bSenderHigh ? lsfLowReserve : lsfHighReserve) // Sender reserve is set.
|
|
&& !sleRippleState->getFieldAmount (!bSenderHigh ? sfLowLimit : sfHighLimit) // Sender trust limit is 0.
|
|
&& !sleRippleState->getFieldU32 (!bSenderHigh ? sfLowQualityIn : sfHighQualityIn) // Sender quality in is 0.
|
|
&& !sleRippleState->getFieldU32 (!bSenderHigh ? sfLowQualityOut : sfHighQualityOut)) // Sender quality out is 0.
|
|
{
|
|
// Clear the reserve of the sender, possibly delete the line!
|
|
SLE::pointer sleSender = entryCache (ltACCOUNT_ROOT, Ledger::getAccountRootIndex (uSenderID));
|
|
|
|
ownerCountAdjust (uSenderID, -1, sleSender);
|
|
|
|
sleRippleState->setFieldU32 (sfFlags, uFlags & (!bSenderHigh ? ~lsfLowReserve : ~lsfHighReserve)); // Clear reserve flag.
|
|
|
|
bDelete = !saBalance // Balance is zero.
|
|
&& !isSetBit (uFlags, bSenderHigh ? lsfLowReserve : lsfHighReserve); // Receiver reserve is clear.
|
|
}
|
|
|
|
if (bSenderHigh)
|
|
saBalance.negate ();
|
|
|
|
// Want to reflect balance to zero even if we are deleting line.
|
|
sleRippleState->setFieldAmount (sfBalance, saBalance); // ONLY: Adjust ripple balance.
|
|
|
|
if (bDelete)
|
|
{
|
|
terResult = trustDelete (sleRippleState,
|
|
bSenderHigh ? uReceiverID : uSenderID,
|
|
!bSenderHigh ? uReceiverID : uSenderID);
|
|
}
|
|
else
|
|
{
|
|
entryModify (sleRippleState);
|
|
|
|
terResult = tesSUCCESS;
|
|
}
|
|
}
|
|
|
|
return terResult;
|
|
}
|
|
|
|
// Send regardless of limits.
|
|
// --> saAmount: Amount/currency/issuer to deliver to reciever.
|
|
// <-- saActual: Amount actually cost. Sender pay's fees.
|
|
TER LedgerEntrySet::rippleSend (const uint160& uSenderID, const uint160& uReceiverID, const STAmount& saAmount, STAmount& saActual)
|
|
{
|
|
const uint160 uIssuerID = saAmount.getIssuer ();
|
|
TER terResult;
|
|
|
|
assert (!!uSenderID && !!uReceiverID);
|
|
assert (uSenderID != uReceiverID);
|
|
|
|
if (uSenderID == uIssuerID || uReceiverID == uIssuerID || uIssuerID == ACCOUNT_ONE)
|
|
{
|
|
// Direct send: redeeming IOUs and/or sending own IOUs.
|
|
terResult = rippleCredit (uSenderID, uReceiverID, saAmount, false);
|
|
|
|
saActual = saAmount;
|
|
|
|
terResult = tesSUCCESS;
|
|
}
|
|
else
|
|
{
|
|
// Sending 3rd party IOUs: transit.
|
|
|
|
STAmount saTransitFee = rippleTransferFee (uSenderID, uReceiverID, uIssuerID, saAmount);
|
|
|
|
saActual = !saTransitFee ? saAmount : saAmount + saTransitFee;
|
|
|
|
saActual.setIssuer (uIssuerID); // XXX Make sure this done in + above.
|
|
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << boost::str (boost::format ("rippleSend> %s -- > %s : deliver=%s fee=%s cost=%s")
|
|
% RippleAddress::createHumanAccountID (uSenderID)
|
|
% RippleAddress::createHumanAccountID (uReceiverID)
|
|
% saAmount.getFullText ()
|
|
% saTransitFee.getFullText ()
|
|
% saActual.getFullText ());
|
|
|
|
terResult = rippleCredit (uIssuerID, uReceiverID, saAmount);
|
|
|
|
if (tesSUCCESS == terResult)
|
|
terResult = rippleCredit (uSenderID, uIssuerID, saActual);
|
|
}
|
|
|
|
return terResult;
|
|
}
|
|
|
|
TER LedgerEntrySet::accountSend (const uint160& uSenderID, const uint160& uReceiverID, const STAmount& saAmount)
|
|
{
|
|
TER terResult = tesSUCCESS;
|
|
|
|
assert (!saAmount.isNegative ());
|
|
|
|
if (!saAmount || (uSenderID == uReceiverID))
|
|
{
|
|
nothing ();
|
|
}
|
|
else if (saAmount.isNative ())
|
|
{
|
|
// XRP send which does not check reserve and can do pure adjustment.
|
|
SLE::pointer sleSender = !!uSenderID
|
|
? entryCache (ltACCOUNT_ROOT, Ledger::getAccountRootIndex (uSenderID))
|
|
: SLE::pointer ();
|
|
SLE::pointer sleReceiver = !!uReceiverID
|
|
? entryCache (ltACCOUNT_ROOT, Ledger::getAccountRootIndex (uReceiverID))
|
|
: SLE::pointer ();
|
|
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << boost::str (boost::format ("accountSend> %s (%s) -> %s (%s) : %s")
|
|
% RippleAddress::createHumanAccountID (uSenderID)
|
|
% (sleSender ? (sleSender->getFieldAmount (sfBalance)).getFullText () : "-")
|
|
% RippleAddress::createHumanAccountID (uReceiverID)
|
|
% (sleReceiver ? (sleReceiver->getFieldAmount (sfBalance)).getFullText () : "-")
|
|
% saAmount.getFullText ());
|
|
|
|
if (sleSender)
|
|
{
|
|
if (sleSender->getFieldAmount (sfBalance) < saAmount)
|
|
{
|
|
terResult = isSetBit (mParams, tapOPEN_LEDGER) ? telFAILED_PROCESSING : tecFAILED_PROCESSING;
|
|
}
|
|
else
|
|
{
|
|
sleSender->setFieldAmount (sfBalance, sleSender->getFieldAmount (sfBalance) - saAmount); // Decrement XRP balance.
|
|
entryModify (sleSender);
|
|
}
|
|
}
|
|
|
|
if (tesSUCCESS == terResult && sleReceiver)
|
|
{
|
|
sleReceiver->setFieldAmount (sfBalance, sleReceiver->getFieldAmount (sfBalance) + saAmount); // Increment XRP balance.
|
|
entryModify (sleReceiver);
|
|
}
|
|
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << boost::str (boost::format ("accountSend< %s (%s) -> %s (%s) : %s")
|
|
% RippleAddress::createHumanAccountID (uSenderID)
|
|
% (sleSender ? (sleSender->getFieldAmount (sfBalance)).getFullText () : "-")
|
|
% RippleAddress::createHumanAccountID (uReceiverID)
|
|
% (sleReceiver ? (sleReceiver->getFieldAmount (sfBalance)).getFullText () : "-")
|
|
% saAmount.getFullText ());
|
|
}
|
|
else
|
|
{
|
|
STAmount saActual;
|
|
|
|
WriteLog (lsDEBUG, LedgerEntrySet) << boost::str (boost::format ("accountSend: %s -> %s : %s")
|
|
% RippleAddress::createHumanAccountID (uSenderID)
|
|
% RippleAddress::createHumanAccountID (uReceiverID)
|
|
% saAmount.getFullText ());
|
|
|
|
|
|
terResult = rippleSend (uSenderID, uReceiverID, saAmount, saActual);
|
|
}
|
|
|
|
return terResult;
|
|
}
|
|
|
|
// vim:ts=4
|