mirror of
https://github.com/Xahau/xahaud.git
synced 2025-12-06 17:27:52 +00:00
1022 lines
33 KiB
C++
1022 lines
33 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
This file is part of rippled: https://github.com/ripple/rippled
|
|
Copyright (c) 2012, 2013 Ripple Labs Inc.
|
|
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted, provided that the above
|
|
copyright notice and this permission notice appear in all copies.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
//==============================================================================
|
|
|
|
#include <tuple>
|
|
|
|
#include <ripple/module/app/paths/Calculators.h>
|
|
|
|
namespace ripple {
|
|
|
|
/*
|
|
we just need to find a succession of the highest quality paths there until we find enough width
|
|
|
|
Don't do branching within each path
|
|
|
|
We have a list of paths we are working on but how do we compare the ones that
|
|
are terminating in a different currency?
|
|
|
|
Loops
|
|
|
|
TODO: what is a good way to come up with multiple paths?
|
|
Maybe just change the sort criteria?
|
|
first a low cost one and then a fat short one?
|
|
|
|
|
|
OrderDB:
|
|
getXRPOffers();
|
|
|
|
// return list of all orderbooks that want XRP
|
|
// return list of all orderbooks that want IssuerID
|
|
// return list of all orderbooks that want this issuerID and currencyID
|
|
*/
|
|
|
|
/*
|
|
Test sending to XRP
|
|
Test XRP to XRP
|
|
Test offer in middle
|
|
Test XRP to USD
|
|
Test USD to EUR
|
|
*/
|
|
|
|
// we sort the options by:
|
|
// cost of path
|
|
// length of path
|
|
// width of path
|
|
// correct currency at the end
|
|
|
|
// quality, length, liquidity, index
|
|
typedef std::tuple<std::uint64_t, int, STAmount, unsigned int> path_LQ_t;
|
|
|
|
// Lower numbers have better quality. Sort higher quality first.
|
|
static bool bQualityCmp (const path_LQ_t& a, const path_LQ_t& b)
|
|
{
|
|
// 1) Higher quality (lower cost) is better
|
|
if (std::get<0> (a) != std::get<0> (b))
|
|
return std::get<0> (a) < std::get<0> (b);
|
|
|
|
// 2) More liquidity (higher volume) is better
|
|
if (std::get<2> (a) != std::get<2> (b))
|
|
return std::get<2> (a) > std::get<2> (b);
|
|
|
|
// 3) Shorter paths are better
|
|
if (std::get<1> (a) != std::get<1> (b))
|
|
return std::get<1> (a) < std::get<1> (b);
|
|
|
|
// 4) Tie breaker
|
|
return std::get<3> (a) > std::get<3> (b);
|
|
}
|
|
|
|
typedef std::pair<int, Account> AccountCandidate;
|
|
typedef std::vector<AccountCandidate> AccountCandidates;
|
|
|
|
static bool candCmp (
|
|
std::uint32_t seq,
|
|
const AccountCandidate& first, const AccountCandidate& second)
|
|
{
|
|
if (first.first < second.first)
|
|
return false;
|
|
|
|
if (first.first > second.first)
|
|
return true;
|
|
|
|
return (first.first ^ seq) < (second.first ^ seq);
|
|
}
|
|
|
|
Pathfinder::Pathfinder (
|
|
RippleLineCache::ref cache,
|
|
const RippleAddress& uSrcAccountID,
|
|
const RippleAddress& uDstAccountID,
|
|
Currency const& uSrcCurrencyID,
|
|
Account const& uSrcIssuerID,
|
|
const STAmount& saDstAmount,
|
|
bool& bValid)
|
|
: mSrcAccountID (uSrcAccountID.getAccountID ()),
|
|
mDstAccountID (uDstAccountID.getAccountID ()),
|
|
mDstAmount (saDstAmount),
|
|
mSrcCurrencyID (uSrcCurrencyID),
|
|
mSrcIssuerID (uSrcIssuerID),
|
|
mSrcAmount ({uSrcCurrencyID, uSrcIssuerID}, 1u, 0, true),
|
|
mLedger (cache->getLedger ()), mRLCache (cache)
|
|
{
|
|
|
|
if ((mSrcAccountID == mDstAccountID &&
|
|
mSrcCurrencyID == mDstAmount.getCurrency ()) || mDstAmount == zero)
|
|
{
|
|
// no need to send to same account with same currency, must send non-zero
|
|
bValid = false;
|
|
mLedger.reset ();
|
|
return;
|
|
}
|
|
|
|
bValid = true;
|
|
|
|
m_loadEvent = getApp().getJobQueue ().getLoadEvent (
|
|
jtPATH_FIND, "FindPath");
|
|
|
|
bool bIssuer = mSrcCurrencyID.isNonZero() &&
|
|
mSrcIssuerID.isNonZero() &&
|
|
(mSrcIssuerID != mSrcAccountID);
|
|
mSource = STPathElement(
|
|
// Where does an empty path start?
|
|
bIssuer ? mSrcIssuerID : mSrcAccountID,
|
|
// On the source account or issuer account
|
|
mSrcCurrencyID,
|
|
// In the source currency
|
|
mSrcCurrencyID.isZero() ? Account() :
|
|
(bIssuer ? mSrcIssuerID : mSrcAccountID));
|
|
}
|
|
|
|
bool Pathfinder::findPaths (
|
|
int iLevel, const unsigned int iMaxPaths,
|
|
STPathSet& pathsOut, STPath& extraPath)
|
|
{
|
|
// pathsOut contains only non-default paths without source or
|
|
// destination. On input, pathsOut contains any paths you want to ensure are
|
|
// included if still good.
|
|
|
|
WriteLog (lsTRACE, Pathfinder)
|
|
<< "findPaths>"
|
|
<< " mSrcAccountID=" << mSrcAccountID
|
|
<< " mDstAccountID=" << mDstAccountID
|
|
<< " mDstAmount=" << mDstAmount.getFullText ()
|
|
<< " mSrcCurrencyID=" << mSrcCurrencyID
|
|
<< " mSrcIssuerID=" << mSrcIssuerID;
|
|
|
|
if (!mLedger)
|
|
{
|
|
WriteLog (lsDEBUG, Pathfinder) << "findPaths< no ledger";
|
|
|
|
return false;
|
|
}
|
|
|
|
bool bSrcXrp = mSrcCurrencyID.isZero();
|
|
bool bDstXrp = mDstAmount.getCurrency().isZero();
|
|
|
|
auto sleSrc = mLedger->getSLEi(Ledger::getAccountRootIndex(mSrcAccountID));
|
|
if (!sleSrc)
|
|
return false;
|
|
|
|
auto sleDest = mLedger->getSLEi(Ledger::getAccountRootIndex(mDstAccountID));
|
|
if (!sleDest && (!bDstXrp || (mDstAmount < mLedger->getReserve(0))))
|
|
return false;
|
|
|
|
PaymentType paymentType;
|
|
if (bSrcXrp && bDstXrp)
|
|
{ // XRP -> XRP
|
|
|
|
WriteLog (lsDEBUG, Pathfinder) << "XRP to XRP payment";
|
|
paymentType = pt_XRP_to_XRP;
|
|
|
|
}
|
|
else if (bSrcXrp)
|
|
{ // XRP -> non-XRP
|
|
|
|
WriteLog (lsDEBUG, Pathfinder) << "XRP to non-XRP payment";
|
|
paymentType = pt_XRP_to_nonXRP;
|
|
|
|
}
|
|
else if (bDstXrp)
|
|
{ // non-XRP -> XRP
|
|
|
|
WriteLog (lsDEBUG, Pathfinder) << "non-XRP to XRP payment";
|
|
paymentType = pt_nonXRP_to_XRP;
|
|
|
|
}
|
|
else if (mSrcCurrencyID == mDstAmount.getCurrency())
|
|
{ // non-XRP -> non-XRP - Same currency
|
|
|
|
WriteLog (lsDEBUG, Pathfinder) << "non-XRP to non-XRP - same currency";
|
|
paymentType = pt_nonXRP_to_same;
|
|
|
|
}
|
|
else
|
|
{ // non-XRP to non-XRP - Different currency
|
|
|
|
WriteLog (lsDEBUG, Pathfinder) << "non-XRP to non-XRP - cross currency";
|
|
paymentType = pt_nonXRP_to_nonXRP;
|
|
|
|
}
|
|
|
|
BOOST_FOREACH(CostedPath_t const& costedPath, mPathTable[paymentType])
|
|
{
|
|
if (costedPath.first <= iLevel)
|
|
{
|
|
getPaths(costedPath.second);
|
|
if (mCompletePaths.size () > PATHFINDER_MAX_COMPLETE_PATHS)
|
|
break;
|
|
}
|
|
}
|
|
|
|
WriteLog (lsDEBUG, Pathfinder)
|
|
<< mCompletePaths.size() << " complete paths found";
|
|
|
|
BOOST_FOREACH(const STPath& path, pathsOut)
|
|
{ // make sure no paths were lost
|
|
bool found = false;
|
|
if (!path.isEmpty ())
|
|
{
|
|
BOOST_FOREACH(const STPath& ePath, mCompletePaths)
|
|
{
|
|
if (ePath == path)
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found)
|
|
mCompletePaths.addPath(path);
|
|
}
|
|
}
|
|
|
|
WriteLog (lsDEBUG, Pathfinder) << mCompletePaths.size() << " paths to filter";
|
|
|
|
if (mCompletePaths.size() > iMaxPaths)
|
|
pathsOut = filterPaths(iMaxPaths, extraPath);
|
|
else
|
|
pathsOut = mCompletePaths;
|
|
|
|
// Even if we find no paths, default paths may work, and we don't check them
|
|
// currently.
|
|
return true;
|
|
}
|
|
|
|
STPathSet Pathfinder::filterPaths(int iMaxPaths, STPath& extraPath)
|
|
{
|
|
if (mCompletePaths.size() <= iMaxPaths)
|
|
return mCompletePaths;
|
|
|
|
STAmount remaining = mDstAmount;
|
|
|
|
// must subtract liquidity in default path from remaining amount
|
|
try
|
|
{
|
|
STAmount saMaxAmountAct, saDstAmountAct;
|
|
PathState::List pathStateList;
|
|
LedgerEntrySet lesSandbox (mLedger, tapNONE);
|
|
|
|
TER result = path::rippleCalculate (
|
|
lesSandbox,
|
|
saMaxAmountAct,
|
|
saDstAmountAct,
|
|
pathStateList,
|
|
mSrcAmount,
|
|
mDstAmount,
|
|
mDstAccountID,
|
|
mSrcAccountID,
|
|
STPathSet (),
|
|
true, // allow partial payment
|
|
false,
|
|
false, // don't suppress default paths, that's the point
|
|
true);
|
|
|
|
if (tesSUCCESS == result)
|
|
{
|
|
WriteLog (lsDEBUG, Pathfinder)
|
|
<< "Default path contributes: " << saDstAmountAct;
|
|
remaining -= saDstAmountAct;
|
|
}
|
|
else
|
|
{
|
|
WriteLog (lsDEBUG, Pathfinder)
|
|
<< "Default path fails: " << transToken (result);
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
WriteLog (lsDEBUG, Pathfinder) << "Default path causes exception";
|
|
}
|
|
|
|
std::vector<path_LQ_t> vMap;
|
|
|
|
// Ignore paths that move only very small amounts
|
|
auto saMinDstAmount = STAmount::divide(
|
|
mDstAmount, STAmount(iMaxPaths + 2), mDstAmount);
|
|
|
|
// Build map of quality to entry.
|
|
for (int i = mCompletePaths.size (); i--;)
|
|
{
|
|
STAmount saMaxAmountAct;
|
|
STAmount saDstAmountAct;
|
|
PathState::List pathStateList;
|
|
STPathSet spsPaths;
|
|
STPath& spCurrent = mCompletePaths[i];
|
|
|
|
spsPaths.addPath (spCurrent); // Just checking the current path.
|
|
|
|
TER resultCode;
|
|
|
|
try
|
|
{
|
|
LedgerEntrySet lesSandbox (mLedger, tapNONE);
|
|
|
|
resultCode = path::rippleCalculate (
|
|
lesSandbox,
|
|
saMaxAmountAct, // --> computed input
|
|
saDstAmountAct, // --> computed output
|
|
pathStateList,
|
|
mSrcAmount, // --> amount to send max.
|
|
mDstAmount, // --> amount to deliver.
|
|
mDstAccountID,
|
|
mSrcAccountID,
|
|
spsPaths,
|
|
true, // --> bPartialPayment: Allow, it might contribute.
|
|
false, // --> bLimitQuality: Assume normal transaction.
|
|
true, // --> bNoRippleDirect: Providing the only path.
|
|
true); // --> bStandAlone: Don't need to delete unfundeds.
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
WriteLog (lsINFO, Pathfinder)
|
|
<< "findPaths: Caught throw: " << e.what ();
|
|
resultCode = tefEXCEPTION;
|
|
}
|
|
|
|
if (resultCode != tesSUCCESS)
|
|
{
|
|
WriteLog (lsDEBUG, Pathfinder) <<
|
|
"findPaths: dropping: " << transToken (resultCode) <<
|
|
": " << spCurrent.getJson (0);
|
|
}
|
|
else if (saDstAmountAct < saMinDstAmount)
|
|
{
|
|
WriteLog (lsDEBUG, Pathfinder) <<
|
|
"findPaths: dropping: outputs " << saDstAmountAct <<
|
|
": %s" << spCurrent.getJson (0);
|
|
}
|
|
else
|
|
{
|
|
std::uint64_t uQuality (
|
|
STAmount::getRate (saDstAmountAct, saMaxAmountAct));
|
|
|
|
WriteLog (lsDEBUG, Pathfinder) <<
|
|
"findPaths: quality: " << uQuality <<
|
|
": " << spCurrent.getJson (0);
|
|
|
|
vMap.push_back (path_LQ_t (
|
|
uQuality, spCurrent.mPath.size (), saDstAmountAct, i));
|
|
}
|
|
}
|
|
|
|
STPathSet spsDst;
|
|
|
|
if (vMap.size())
|
|
{
|
|
// Lower is better and should be first.
|
|
std::sort (vMap.begin (), vMap.end (), bQualityCmp);
|
|
|
|
|
|
for (int i = 0, iPathsLeft = iMaxPaths;
|
|
(iPathsLeft > 0 || extraPath.empty()) && i < vMap.size (); ++i)
|
|
{
|
|
path_LQ_t& lqt = vMap[i];
|
|
|
|
if (iPathsLeft > 1 ||
|
|
(iPathsLeft > 0 && std::get<2> (lqt) >= remaining))
|
|
{
|
|
// last path must fill
|
|
--iPathsLeft;
|
|
remaining -= std::get<2> (lqt);
|
|
spsDst.addPath (mCompletePaths[std::get<3> (lqt)]);
|
|
}
|
|
else if (iPathsLeft == 0 && std::get<2>(lqt) >= mDstAmount &&
|
|
extraPath.empty())
|
|
{
|
|
// found an extra path that can move the whole amount
|
|
extraPath = mCompletePaths[std::get<3>(lqt)];
|
|
WriteLog (lsDEBUG, Pathfinder) <<
|
|
"Found extra full path: " << extraPath.getJson(0);
|
|
}
|
|
else
|
|
WriteLog (lsDEBUG, Pathfinder) <<
|
|
"Skipping a non-filling path: " <<
|
|
mCompletePaths[std::get<3> (lqt)].getJson (0);
|
|
}
|
|
|
|
if (remaining > zero)
|
|
{
|
|
WriteLog (lsINFO, Pathfinder) <<
|
|
"Paths could not send " << remaining << " of " << mDstAmount;
|
|
}
|
|
else
|
|
{
|
|
WriteLog (lsDEBUG, Pathfinder) <<
|
|
"findPaths: RESULTS: " << spsDst.getJson (0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WriteLog (lsDEBUG, Pathfinder) <<
|
|
"findPaths: RESULTS: non-defaults filtered away";
|
|
}
|
|
|
|
return spsDst;
|
|
}
|
|
|
|
CurrencySet usAccountSourceCurrencies (
|
|
const RippleAddress& raAccountID, RippleLineCache::ref lrCache,
|
|
bool includeXRP)
|
|
{
|
|
CurrencySet usCurrencies;
|
|
|
|
// YYY Only bother if they are above reserve
|
|
if (includeXRP)
|
|
usCurrencies.insert (xrpCurrency());
|
|
|
|
// List of ripple lines.
|
|
auto& rippleLines (lrCache->getRippleLines (raAccountID.getAccountID ()));
|
|
|
|
for (auto item: rippleLines.getItems ())
|
|
{
|
|
RippleState* rspEntry = (RippleState*) item.get ();
|
|
const STAmount& saBalance = rspEntry->getBalance ();
|
|
|
|
// Filter out non
|
|
if (saBalance > zero
|
|
// Have IOUs to send.
|
|
|| (rspEntry->getLimitPeer ()
|
|
// Peer extends credit.
|
|
&& ((-saBalance) < rspEntry->getLimitPeer ()))) // Credit left.
|
|
{
|
|
usCurrencies.insert (saBalance.getCurrency ());
|
|
}
|
|
}
|
|
|
|
usCurrencies.erase (badCurrency());
|
|
return usCurrencies;
|
|
}
|
|
|
|
CurrencySet usAccountDestCurrencies (
|
|
const RippleAddress& raAccountID,
|
|
RippleLineCache::ref lrCache,
|
|
bool includeXRP)
|
|
{
|
|
CurrencySet usCurrencies;
|
|
|
|
if (includeXRP)
|
|
usCurrencies.insert (xrpCurrency());
|
|
// Even if account doesn't exist
|
|
|
|
// List of ripple lines.
|
|
auto& rippleLines (lrCache->getRippleLines (raAccountID.getAccountID ()));
|
|
|
|
for (auto item: rippleLines.getItems ())
|
|
{
|
|
RippleState* rspEntry = (RippleState*) item.get ();
|
|
const STAmount& saBalance = rspEntry->getBalance ();
|
|
|
|
if (saBalance < rspEntry->getLimit ()) // Can take more
|
|
usCurrencies.insert (saBalance.getCurrency ());
|
|
}
|
|
|
|
usCurrencies.erase (badCurrency());
|
|
return usCurrencies;
|
|
}
|
|
|
|
bool Pathfinder::matchesOrigin (Currency const& currency, Account const& issuer)
|
|
{
|
|
if (currency != mSrcCurrencyID)
|
|
return false;
|
|
|
|
if (currency.isZero())
|
|
return true;
|
|
|
|
return (issuer == mSrcIssuerID) || (issuer == mSrcAccountID);
|
|
}
|
|
|
|
// VFALCO TODO Use Currency, RippleAccount, et. al. in argument list here
|
|
int Pathfinder::getPathsOut (
|
|
Currency const& currencyID, Account const& accountID,
|
|
bool isDstCurrency, Account const& dstAccount)
|
|
{
|
|
// VFALCO TODO Use Issue here
|
|
auto currencyAccount = std::make_pair(currencyID, accountID);
|
|
auto it = mPOMap.find (currencyAccount);
|
|
|
|
if (it != mPOMap.end ())
|
|
return it->second;
|
|
|
|
auto sleAccount = mLedger->getSLEi(Ledger::getAccountRootIndex(accountID));
|
|
if (!sleAccount)
|
|
{
|
|
mPOMap[currencyAccount] = 0;
|
|
return 0;
|
|
}
|
|
|
|
int aFlags = sleAccount->getFieldU32(sfFlags);
|
|
bool const bAuthRequired = (aFlags & lsfRequireAuth) != 0;
|
|
|
|
int count = 0;
|
|
AccountItems& rippleLines (mRLCache->getRippleLines (accountID));
|
|
|
|
BOOST_FOREACH (AccountItem::ref item, rippleLines.getItems ())
|
|
{
|
|
RippleState* rspEntry = (RippleState*) item.get ();
|
|
|
|
if (currencyID != rspEntry->getLimit ().getCurrency ())
|
|
{
|
|
}
|
|
else if (rspEntry->getBalance () <= zero &&
|
|
(!rspEntry->getLimitPeer ()
|
|
|| -rspEntry->getBalance () >= rspEntry->getLimitPeer ()
|
|
|| (bAuthRequired && !rspEntry->getAuth ())))
|
|
{
|
|
}
|
|
else if (isDstCurrency && (dstAccount == rspEntry->getAccountIDPeer ()))
|
|
count += 10000; // count a path to the destination extra
|
|
else if (rspEntry->getNoRipplePeer ())
|
|
{
|
|
// This probably isn't a useful path out
|
|
}
|
|
else
|
|
++count;
|
|
}
|
|
mPOMap[currencyAccount] = count;
|
|
return count;
|
|
}
|
|
|
|
void Pathfinder::addLink(
|
|
const STPathSet& currentPaths, // The paths to build from
|
|
STPathSet& incompletePaths, // The set of partial paths we add to
|
|
int addFlags)
|
|
{
|
|
WriteLog (lsDEBUG, Pathfinder) << "addLink< on " << currentPaths.size() << " source(s), flags=" << addFlags;
|
|
BOOST_FOREACH(const STPath& path, currentPaths)
|
|
{
|
|
addLink(path, incompletePaths, addFlags);
|
|
}
|
|
}
|
|
|
|
STPathSet& Pathfinder::getPaths(PathType_t const& type, bool addComplete)
|
|
{
|
|
std::map< PathType_t, STPathSet >::iterator it = mPaths.find(type);
|
|
|
|
// We already have these paths
|
|
if (it != mPaths.end())
|
|
return it->second;
|
|
|
|
// The type is empty
|
|
if (type.empty())
|
|
return mPaths[type];
|
|
|
|
NodeType toAdd = type.back();
|
|
PathType_t pathType(type);
|
|
pathType.pop_back();
|
|
|
|
STPathSet pathsIn = getPaths(pathType, false);
|
|
STPathSet& pathsOut = mPaths[type];
|
|
|
|
WriteLog (lsDEBUG, Pathfinder)
|
|
<< "getPaths< adding onto '"
|
|
<< pathTypeToString(pathType) << "' to get '"
|
|
<< pathTypeToString(type) << "'";
|
|
|
|
int cp = mCompletePaths.size();
|
|
|
|
switch (toAdd)
|
|
{
|
|
|
|
case nt_SOURCE:
|
|
|
|
{ // source is an empty path
|
|
assert(pathsOut.isEmpty());
|
|
pathsOut.addPath(STPath());
|
|
}
|
|
break;
|
|
|
|
case nt_ACCOUNTS:
|
|
addLink(pathsIn, pathsOut, afADD_ACCOUNTS);
|
|
break;
|
|
|
|
case nt_BOOKS:
|
|
addLink(pathsIn, pathsOut, afADD_BOOKS);
|
|
break;
|
|
|
|
case nt_XRP_BOOK:
|
|
addLink(pathsIn, pathsOut, afADD_BOOKS | afOB_XRP);
|
|
break;
|
|
|
|
case nt_DEST_BOOK:
|
|
addLink(pathsIn, pathsOut, afADD_BOOKS | afOB_LAST);
|
|
break;
|
|
|
|
case nt_DESTINATION:
|
|
// FIXME: What if a different issuer was specified on the destination amount
|
|
addLink(pathsIn, pathsOut, afADD_ACCOUNTS | afAC_LAST);
|
|
break;
|
|
|
|
}
|
|
|
|
CondLog (mCompletePaths.size() != cp, lsDEBUG, Pathfinder)
|
|
<< (mCompletePaths.size() - cp)
|
|
<< " complete paths added";
|
|
WriteLog (lsDEBUG, Pathfinder) << "getPaths> " << pathsOut.size() << " partial paths found";
|
|
return pathsOut;
|
|
}
|
|
|
|
bool Pathfinder::isNoRipple (
|
|
Account const& setByID, Account const& setOnID, Currency const& currencyID)
|
|
{
|
|
SLE::pointer sleRipple = mLedger->getSLEi (
|
|
Ledger::getRippleStateIndex (setByID, setOnID, currencyID));
|
|
|
|
auto const flag ((setByID > setOnID) ? lsfHighNoRipple : lsfLowNoRipple);
|
|
|
|
return sleRipple && (sleRipple->getFieldU32 (sfFlags) & flag);
|
|
}
|
|
|
|
// Does this path end on an account-to-account link whose last account
|
|
// has set no ripple on the link?
|
|
bool Pathfinder::isNoRippleOut (const STPath& currentPath)
|
|
{
|
|
// Must have at least one link
|
|
if (currentPath.size() == 0)
|
|
return false;
|
|
|
|
// Last link must be an account
|
|
STPathElement const& endElement = *(currentPath.end() - 1);
|
|
if (!(endElement.getNodeType() & STPathElement::typeAccount))
|
|
return false;
|
|
|
|
// What account are we leaving?
|
|
auto const& fromAccount =
|
|
(currentPath.size() == 1) ? mSrcAccountID : (currentPath.end() - 2)->mAccountID;
|
|
|
|
return isNoRipple (endElement.mAccountID, fromAccount, endElement.mCurrencyID);
|
|
}
|
|
|
|
void Pathfinder::addLink(
|
|
const STPath& currentPath, // The path to build from
|
|
STPathSet& incompletePaths, // The set of partial paths we add to
|
|
int addFlags)
|
|
{
|
|
STPathElement const& pathEnd = currentPath.isEmpty() ? mSource : currentPath.mPath.back ();
|
|
auto const& uEndCurrency = pathEnd.mCurrencyID;
|
|
auto const& uEndIssuer = pathEnd.mIssuerID;
|
|
auto const& uEndAccount = pathEnd.mAccountID;
|
|
bool const bOnXRP = uEndCurrency.isZero();
|
|
|
|
WriteLog (lsTRACE, Pathfinder) << "addLink< flags=" << addFlags << " onXRP=" << bOnXRP;
|
|
WriteLog (lsTRACE, Pathfinder) << currentPath.getJson(0);
|
|
|
|
if (addFlags & afADD_ACCOUNTS)
|
|
{ // add accounts
|
|
if (bOnXRP)
|
|
{
|
|
if (mDstAmount.isNative() && !currentPath.isEmpty())
|
|
{ // non-default path to XRP destination
|
|
WriteLog (lsTRACE, Pathfinder) << "complete path found ax: " << currentPath.getJson(0);
|
|
mCompletePaths.addUniquePath(currentPath);
|
|
}
|
|
}
|
|
else
|
|
{ // search for accounts to add
|
|
auto sleEnd = mLedger->getSLEi(
|
|
Ledger::getAccountRootIndex(uEndAccount));
|
|
if (sleEnd)
|
|
{
|
|
bool const bRequireAuth (
|
|
sleEnd->getFieldU32(sfFlags) & lsfRequireAuth);
|
|
bool const bIsEndCurrency (
|
|
uEndCurrency == mDstAmount.getCurrency());
|
|
bool const bIsNoRippleOut (
|
|
isNoRippleOut (currentPath));
|
|
|
|
auto& rippleLines (mRLCache->getRippleLines(uEndAccount));
|
|
|
|
AccountCandidates candidates;
|
|
candidates.reserve(rippleLines.getItems().size());
|
|
|
|
for(auto const& item : rippleLines.getItems())
|
|
{
|
|
auto* rs = dynamic_cast<RippleState const *> (item.get());
|
|
if (!rs)
|
|
{
|
|
WriteLog (lsERROR, Pathfinder)
|
|
<< "Couldn't decipher RippleState";
|
|
continue;
|
|
}
|
|
auto const& acctID = rs->getAccountIDPeer();
|
|
|
|
if ((uEndCurrency == rs->getLimit().getCurrency()) &&
|
|
!currentPath.hasSeen(acctID, uEndCurrency, acctID))
|
|
{ // path is for correct currency and has not been seen
|
|
if (rs->getBalance() <= zero
|
|
&& (!rs->getLimitPeer()
|
|
|| -rs->getBalance() >= rs->getLimitPeer()
|
|
|| (bRequireAuth && !rs->getAuth())))
|
|
{
|
|
// path has no credit
|
|
}
|
|
else if (bIsNoRippleOut && rs->getNoRipple())
|
|
{
|
|
// Can't leave on this path
|
|
}
|
|
else if (acctID == mDstAccountID)
|
|
{ // destination is always worth trying
|
|
if (uEndCurrency == mDstAmount.getCurrency())
|
|
{ // this is a complete path
|
|
if (!currentPath.isEmpty())
|
|
{
|
|
WriteLog (lsTRACE, Pathfinder)
|
|
<< "complete path found ae: "
|
|
<< currentPath.getJson(0);
|
|
mCompletePaths.addUniquePath(currentPath);
|
|
}
|
|
}
|
|
else if ((addFlags & afAC_LAST) == 0)
|
|
{ // this is a high-priority candidate
|
|
candidates.push_back(std::make_pair(100000, acctID));
|
|
}
|
|
}
|
|
else if (acctID == mSrcAccountID)
|
|
{
|
|
// going back to the source is bad
|
|
}
|
|
else if ((addFlags & afAC_LAST) == 0)
|
|
{ // save this candidate
|
|
int out = getPathsOut(uEndCurrency, acctID, bIsEndCurrency, mDstAccountID);
|
|
if (out)
|
|
candidates.push_back(std::make_pair(out, acctID));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!candidates.empty())
|
|
{
|
|
std::sort (candidates.begin(), candidates.end(),
|
|
std::bind(candCmp, mLedger->getLedgerSeq(),
|
|
std::placeholders::_1,
|
|
std::placeholders::_2));
|
|
|
|
int count = candidates.size();
|
|
if ((count > 10) && (uEndAccount != mSrcAccountID)) // allow more paths from source
|
|
count = 10;
|
|
else if (count > 50)
|
|
count = 50;
|
|
|
|
auto it = candidates.begin();
|
|
while (count-- != 0)
|
|
{ // Add accounts to incompletePaths
|
|
incompletePaths.assembleAdd(currentPath, STPathElement(STPathElement::typeAccount, it->second, uEndCurrency, it->second));
|
|
++it;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
WriteLog(lsWARNING, Pathfinder) << "Path ends on non-existent issuer";
|
|
}
|
|
}
|
|
}
|
|
if (addFlags & afADD_BOOKS)
|
|
{ // add order books
|
|
if (addFlags & afOB_XRP)
|
|
{ // to XRP only
|
|
if (!bOnXRP && getApp().getOrderBookDB().isBookToXRP({uEndCurrency, uEndIssuer}))
|
|
{
|
|
STPathElement pathElement(
|
|
STPathElement::typeCurrency,
|
|
xrpAccount(), xrpCurrency(), xrpAccount());
|
|
incompletePaths.assembleAdd(currentPath, pathElement);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool bDestOnly = (addFlags & afOB_LAST) != 0;
|
|
std::vector<OrderBook::pointer> books;
|
|
getApp().getOrderBookDB().getBooksByTakerPays({uEndCurrency, uEndIssuer}, books);
|
|
WriteLog (lsTRACE, Pathfinder) << books.size() << " books found from this currency/issuer";
|
|
BOOST_FOREACH(OrderBook::ref book, books)
|
|
{
|
|
if (!currentPath.hasSeen (
|
|
xrpAccount(),
|
|
book->getCurrencyOut(),
|
|
book->getIssuerOut()) &&
|
|
!matchesOrigin(
|
|
book->getCurrencyOut(),
|
|
book->getIssuerOut()) &&
|
|
(!bDestOnly ||
|
|
(book->getCurrencyOut() == mDstAmount.getCurrency())))
|
|
{
|
|
STPath newPath(currentPath);
|
|
|
|
if (book->getCurrencyOut().isZero())
|
|
{ // to XRP
|
|
|
|
// add the order book itself
|
|
newPath.addElement(STPathElement(
|
|
STPathElement::typeCurrency,
|
|
xrpAccount(), xrpCurrency(), xrpAccount()));
|
|
|
|
if (mDstAmount.getCurrency().isZero())
|
|
{ // destination is XRP, add account and path is complete
|
|
WriteLog (lsTRACE, Pathfinder) << "complete path found bx: " << currentPath.getJson(0);
|
|
mCompletePaths.addUniquePath(newPath);
|
|
}
|
|
else
|
|
incompletePaths.addPath(newPath);
|
|
}
|
|
else if (!currentPath.hasSeen(book->getIssuerOut(), book->getCurrencyOut(), book->getIssuerOut()))
|
|
{ // Don't want the book if we've already seen the issuer
|
|
// add the order book itself
|
|
newPath.addElement(STPathElement(STPathElement::typeCurrency | STPathElement::typeIssuer,
|
|
xrpAccount(), book->getCurrencyOut(), book->getIssuerOut()));
|
|
|
|
if ((book->getIssuerOut() == mDstAccountID) && book->getCurrencyOut() == mDstAmount.getCurrency())
|
|
{ // with the destination account, this path is complete
|
|
WriteLog (lsTRACE, Pathfinder) << "complete path found ba: " << currentPath.getJson(0);
|
|
mCompletePaths.addUniquePath(newPath);
|
|
}
|
|
else
|
|
{ // add issuer's account, path still incomplete
|
|
incompletePaths.assembleAdd(newPath,
|
|
STPathElement(STPathElement::typeAccount,
|
|
book->getIssuerOut(), book->getCurrencyOut(), book->getIssuerOut()));
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::map<Pathfinder::PaymentType, Pathfinder::CostedPathList_t> Pathfinder::mPathTable;
|
|
|
|
Pathfinder::PathType_t Pathfinder::makePath(char const *string)
|
|
{
|
|
PathType_t ret;
|
|
|
|
while (true)
|
|
{
|
|
switch (*string++)
|
|
{
|
|
case 's': // source
|
|
ret.push_back(nt_SOURCE);
|
|
break;
|
|
|
|
case 'a': // accounts
|
|
ret.push_back(nt_ACCOUNTS);
|
|
break;
|
|
|
|
case 'b': // books
|
|
ret.push_back(nt_BOOKS);
|
|
break;
|
|
|
|
case 'x': // xrp book
|
|
ret.push_back(nt_XRP_BOOK);
|
|
break;
|
|
|
|
case 'f': // book to final currency
|
|
ret.push_back(nt_DEST_BOOK);
|
|
break;
|
|
|
|
case 'd': // destination (with account, if required and not already present)
|
|
ret.push_back(nt_DESTINATION);
|
|
break;
|
|
|
|
case 0:
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string Pathfinder::pathTypeToString(PathType_t const& type)
|
|
{
|
|
std::string ret;
|
|
|
|
BOOST_FOREACH(NodeType const& node, type)
|
|
{
|
|
switch (node)
|
|
{
|
|
case nt_SOURCE:
|
|
ret.append("s");
|
|
break;
|
|
case nt_ACCOUNTS:
|
|
ret.append("a");
|
|
break;
|
|
case nt_BOOKS:
|
|
ret.append("b");
|
|
break;
|
|
case nt_XRP_BOOK:
|
|
ret.append("x");
|
|
break;
|
|
case nt_DEST_BOOK:
|
|
ret.append("f");
|
|
break;
|
|
case nt_DESTINATION:
|
|
ret.append("d");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void Pathfinder::fillPaths(PaymentType type, PathCostList const& costs)
|
|
{
|
|
auto& list = mPathTable[type];
|
|
for (auto& cost: costs)
|
|
list.push_back ({cost.first, makePath(cost.second)});
|
|
}
|
|
|
|
// Costs:
|
|
// 0 = minimum to make some payments possible
|
|
// 1 = include trivial paths to make common cases work
|
|
// 4 = normal fast search level
|
|
// 7 = normal slow search level
|
|
// 10 = most agressive
|
|
|
|
void Pathfinder::initPathTable()
|
|
{
|
|
// CAUTION: Do not include rules that build default paths
|
|
fillPaths(
|
|
pt_XRP_to_XRP, {});
|
|
|
|
fillPaths(
|
|
pt_XRP_to_nonXRP, {
|
|
{1, "sfd"}, // source -> book -> gateway
|
|
{3, "sfad"}, // source -> book -> account -> destination
|
|
{5, "sfaad"}, // source -> book -> account -> account -> destination
|
|
{6, "sbfd"}, // source -> book -> book -> destination
|
|
{8, "sbafd"}, // source -> book -> account -> book -> destination
|
|
{9, "sbfad"}, // source -> book -> book -> account -> destination
|
|
{10, "sbafad"}
|
|
});
|
|
|
|
fillPaths(
|
|
pt_XRP_to_nonXRP, {
|
|
{1, "sfd"},
|
|
{3, "sfad"}, // source -> book -> account -> destination
|
|
{5, "sfaad"}, // source -> book -> account -> account -> destination
|
|
{6, "sbfd"}, // source -> book -> book -> destination
|
|
{8, "sbafd"}, // source -> book -> account -> book -> destination
|
|
{9, "sbfad"}, // source -> book -> book -> account -> destination
|
|
{10, "sbafad"}
|
|
});
|
|
|
|
fillPaths(
|
|
pt_nonXRP_to_XRP, {
|
|
{1, "sxd"}, // gateway buys XRP
|
|
{2, "saxd"}, // source -> gateway -> book(XRP) -> dest
|
|
{6, "saaxd"},
|
|
{7, "sbxd"},
|
|
{8, "sabxd"},
|
|
{9, "sabaxd"}
|
|
});
|
|
|
|
// non-XRP to non-XRP (same currency)
|
|
fillPaths(
|
|
pt_nonXRP_to_same, {
|
|
{1, "sad"}, // source -> gateway -> destination
|
|
{1, "sfd"}, // source -> book -> destination
|
|
{4, "safd"}, // source -> gateway -> book -> destination
|
|
{4, "sfad"},
|
|
{5, "saad"},
|
|
{5, "sbfd"},
|
|
{6, "sxfad"},
|
|
{6, "safad"},
|
|
{6, "saxfd"}, // source -> gateway -> book to XRP -> book ->
|
|
// destination
|
|
{6, "saxfad"},
|
|
{6, "sabfd"}, // source -> gateway -> book -> book -> destination
|
|
{6, "sabfd"},
|
|
{7, "saaad"},
|
|
});
|
|
|
|
// non-XRP to non-XRP (different currency)
|
|
fillPaths(
|
|
pt_nonXRP_to_nonXRP, {
|
|
{1, "sfad"},
|
|
{1, "safd"},
|
|
{3, "safad"},
|
|
{4, "sxfd"},
|
|
{5, "saxfd"},
|
|
{5, "sxfad"},
|
|
{6, "saxfad"},
|
|
{6, "sabfd"},
|
|
{7, "saafd"},
|
|
{8, "saafad"},
|
|
{9, "safaad"},
|
|
});
|
|
}
|
|
|
|
} // ripple
|