mirror of
https://github.com/XRPLF/rippled.git
synced 2025-12-06 17:27:55 +00:00
4b8d227922
Before this change, the deferred credits algorithm took the current balance and subtracted the recorded credits. Conceptually, this is the same as taking the original balance, adding all the credits, subtracting all the debits, and subtracting all the credits. The new algorithm records the original balance and subtracts the debits. This prevents errors that occur when the original balance and the recorded credits have large differences in magnitude. Additionally, XRP credits were recorded incorrectly in the deferred credits table (the line was between the sender and receiver, rather than the root account).
153 lines
4.9 KiB
C++
153 lines
4.9 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 <BeastConfig.h>
|
|
#include <ripple/app/paths/Credit.h>
|
|
#include <ripple/app/paths/Flow.h>
|
|
#include <ripple/app/paths/impl/AmountSpec.h>
|
|
#include <ripple/app/paths/impl/StrandFlow.h>
|
|
#include <ripple/app/paths/impl/Steps.h>
|
|
#include <ripple/basics/Log.h>
|
|
#include <ripple/protocol/IOUAmount.h>
|
|
#include <ripple/protocol/XRPAmount.h>
|
|
|
|
#include <boost/container/flat_set.hpp>
|
|
|
|
#include <numeric>
|
|
#include <sstream>
|
|
|
|
namespace ripple {
|
|
|
|
template<class FlowResult>
|
|
static
|
|
auto finishFlow (PaymentSandbox& sb,
|
|
Issue const& srcIssue, Issue const& dstIssue,
|
|
FlowResult&& f)
|
|
{
|
|
path::RippleCalc::Output result;
|
|
if (f.ter == tesSUCCESS)
|
|
f.sandbox->apply (sb);
|
|
else
|
|
result.removableOffers = std::move (f.removableOffers);
|
|
|
|
result.setResult (f.ter);
|
|
result.actualAmountIn = toSTAmount (f.in, srcIssue);
|
|
result.actualAmountOut = toSTAmount (f.out, dstIssue);
|
|
|
|
return result;
|
|
};
|
|
|
|
path::RippleCalc::Output
|
|
flow (
|
|
PaymentSandbox& sb,
|
|
STAmount const& deliver,
|
|
AccountID const& src,
|
|
AccountID const& dst,
|
|
STPathSet const& paths,
|
|
bool defaultPaths,
|
|
bool partialPayment,
|
|
boost::optional<Quality> const& limitQuality,
|
|
boost::optional<STAmount> const& sendMax,
|
|
beast::Journal j)
|
|
{
|
|
Issue const srcIssue = [&] {
|
|
if (sendMax)
|
|
return sendMax->issue ();
|
|
if (!isXRP (deliver.issue ().currency))
|
|
return Issue (deliver.issue ().currency, src);
|
|
return xrpIssue ();
|
|
}();
|
|
|
|
Issue const dstIssue = deliver.issue ();
|
|
|
|
boost::optional<Issue> sendMaxIssue;
|
|
if (sendMax)
|
|
sendMaxIssue = sendMax->issue ();
|
|
|
|
// convert the paths to a collection of strands. Each strand is the collection
|
|
// of account->account steps and book steps that may be used in this payment.
|
|
auto sr = toStrands (sb, src, dst, dstIssue, sendMaxIssue, paths,
|
|
defaultPaths, j);
|
|
|
|
if (sr.first != tesSUCCESS)
|
|
{
|
|
path::RippleCalc::Output result;
|
|
result.setResult (sr.first);
|
|
return result;
|
|
}
|
|
|
|
auto& strands = sr.second;
|
|
|
|
if (j.trace())
|
|
{
|
|
j.trace() << "\nsrc: " << src << "\ndst: " << dst
|
|
<< "\nsrcIssue: " << srcIssue << "\ndstIssue: " << dstIssue;
|
|
j.trace() << "\nNumStrands: " << strands.size ();
|
|
for (auto const& curStrand : strands)
|
|
{
|
|
j.trace() << "NumSteps: " << curStrand.size ();
|
|
for (auto const& step : curStrand)
|
|
{
|
|
j.trace() << '\n' << *step << '\n';
|
|
}
|
|
}
|
|
}
|
|
|
|
const bool srcIsXRP = isXRP (srcIssue.currency);
|
|
const bool dstIsXRP = isXRP (dstIssue.currency);
|
|
|
|
auto const asDeliver = toAmountSpec (deliver);
|
|
|
|
// The src account may send either xrp or iou. The dst account may receive
|
|
// either xrp or iou. Since XRP and IOU amounts are represented by different
|
|
// types, use templates to tell `flow` about the amount types.
|
|
if (srcIsXRP && dstIsXRP)
|
|
{
|
|
return finishFlow (sb, srcIssue, dstIssue,
|
|
flow<XRPAmount, XRPAmount> (
|
|
sb, strands, asDeliver.xrp, defaultPaths, partialPayment,
|
|
limitQuality, sendMax, j));
|
|
}
|
|
|
|
if (srcIsXRP && !dstIsXRP)
|
|
{
|
|
return finishFlow (sb, srcIssue, dstIssue,
|
|
flow<XRPAmount, IOUAmount> (
|
|
sb, strands, asDeliver.iou, defaultPaths, partialPayment,
|
|
limitQuality, sendMax, j));
|
|
}
|
|
|
|
if (!srcIsXRP && dstIsXRP)
|
|
{
|
|
return finishFlow (sb, srcIssue, dstIssue,
|
|
flow<IOUAmount, XRPAmount> (
|
|
sb, strands, asDeliver.xrp, defaultPaths, partialPayment,
|
|
limitQuality, sendMax, j));
|
|
}
|
|
|
|
assert (!srcIsXRP && !dstIsXRP);
|
|
return finishFlow (sb, srcIssue, dstIssue,
|
|
flow<IOUAmount, IOUAmount> (
|
|
sb, strands, asDeliver.iou, defaultPaths, partialPayment,
|
|
limitQuality, sendMax, j));
|
|
|
|
}
|
|
|
|
} // ripple
|