2#include <xrpl/basics/Number.h>
3#include <xrpl/basics/base_uint.h>
4#include <xrpl/basics/random.h>
5#include <xrpl/beast/hash/uhash.h>
6#include <xrpl/beast/unit_test/suite.h>
7#include <xrpl/beast/utility/Zero.h>
8#include <xrpl/json/json_forwards.h>
9#include <xrpl/json/json_value.h>
10#include <xrpl/protocol/AccountID.h>
11#include <xrpl/protocol/Feature.h>
12#include <xrpl/protocol/IOUAmount.h>
13#include <xrpl/protocol/Indexes.h>
14#include <xrpl/protocol/Issue.h>
15#include <xrpl/protocol/MPTAmount.h>
16#include <xrpl/protocol/MPTIssue.h>
17#include <xrpl/protocol/Protocol.h>
18#include <xrpl/protocol/Rate.h>
19#include <xrpl/protocol/Rules.h>
20#include <xrpl/protocol/SField.h>
21#include <xrpl/protocol/STAmount.h>
22#include <xrpl/protocol/Serializer.h>
23#include <xrpl/protocol/UintTypes.h>
24#include <xrpl/protocol/XRPAmount.h>
75 if (valueDigits == 999999999)
103 BEAST_EXPECT(!res.
native());
107 BEAST_EXPECT(!cmp.
native());
127 BEAST_EXPECT(!prod1.
native());
136 fail(
"Multiplication result is not exact");
148 BEAST_EXPECT(amount.
getText() == value);
152 BEAST_EXPECT(!success);
241 unexpected((zeroSt < zeroSt),
"STAmount fail");
243 unexpected(!(zeroSt < hundred),
"STAmount fail");
246 unexpected(!(one < hundred),
"STAmount fail");
247 unexpected((hundred < zeroSt),
"STAmount fail");
249 unexpected((hundred < hundred),
"STAmount fail");
250 unexpected((zeroSt > zeroSt),
"STAmount fail");
252 unexpected((zeroSt > hundred),
"STAmount fail");
256 unexpected(!(hundred > zeroSt),
"STAmount fail");
257 unexpected(!(hundred > one),
"STAmount fail");
258 unexpected((hundred > hundred),
"STAmount fail");
259 unexpected(!(zeroSt <= zeroSt),
"STAmount fail");
260 unexpected(!(zeroSt <= one),
"STAmount fail");
261 unexpected(!(zeroSt <= hundred),
"STAmount fail");
264 unexpected(!(one <= hundred),
"STAmount fail");
265 unexpected((hundred <= zeroSt),
"STAmount fail");
266 unexpected((hundred <= one),
"STAmount fail");
267 unexpected(!(hundred <= hundred),
"STAmount fail");
268 unexpected(!(zeroSt >= zeroSt),
"STAmount fail");
270 unexpected((zeroSt >= hundred),
"STAmount fail");
271 unexpected(!(one >= zeroSt),
"STAmount fail");
273 unexpected((one >= hundred),
"STAmount fail");
274 unexpected(!(hundred >= zeroSt),
"STAmount fail");
275 unexpected(!(hundred >= one),
"STAmount fail");
276 unexpected(!(hundred >= hundred),
"STAmount fail");
277 unexpected(!(zeroSt == zeroSt),
"STAmount fail");
279 unexpected((zeroSt == hundred),
"STAmount fail");
282 unexpected((one == hundred),
"STAmount fail");
283 unexpected((hundred == zeroSt),
"STAmount fail");
284 unexpected((hundred == one),
"STAmount fail");
285 unexpected(!(hundred == hundred),
"STAmount fail");
286 unexpected((zeroSt != zeroSt),
"STAmount fail");
287 unexpected(!(zeroSt != one),
"STAmount fail");
288 unexpected(!(zeroSt != hundred),
"STAmount fail");
289 unexpected(!(one != zeroSt),
"STAmount fail");
291 unexpected(!(one != hundred),
"STAmount fail");
292 unexpected(!(hundred != zeroSt),
"STAmount fail");
293 unexpected(!(hundred != one),
"STAmount fail");
294 unexpected((hundred != hundred),
"STAmount fail");
303 std::string const cur =
"015841551A748AD2C1F76FF6ECB0CCCD00000000";
327 unexpected((zeroSt < zeroSt),
"STAmount fail");
329 unexpected(!(zeroSt < hundred),
"STAmount fail");
332 unexpected(!(one < hundred),
"STAmount fail");
333 unexpected((hundred < zeroSt),
"STAmount fail");
335 unexpected((hundred < hundred),
"STAmount fail");
336 unexpected((zeroSt > zeroSt),
"STAmount fail");
338 unexpected((zeroSt > hundred),
"STAmount fail");
342 unexpected(!(hundred > zeroSt),
"STAmount fail");
343 unexpected(!(hundred > one),
"STAmount fail");
344 unexpected((hundred > hundred),
"STAmount fail");
345 unexpected(!(zeroSt <= zeroSt),
"STAmount fail");
346 unexpected(!(zeroSt <= one),
"STAmount fail");
347 unexpected(!(zeroSt <= hundred),
"STAmount fail");
350 unexpected(!(one <= hundred),
"STAmount fail");
351 unexpected((hundred <= zeroSt),
"STAmount fail");
352 unexpected((hundred <= one),
"STAmount fail");
353 unexpected(!(hundred <= hundred),
"STAmount fail");
354 unexpected(!(zeroSt >= zeroSt),
"STAmount fail");
356 unexpected((zeroSt >= hundred),
"STAmount fail");
357 unexpected(!(one >= zeroSt),
"STAmount fail");
359 unexpected((one >= hundred),
"STAmount fail");
360 unexpected(!(hundred >= zeroSt),
"STAmount fail");
361 unexpected(!(hundred >= one),
"STAmount fail");
362 unexpected(!(hundred >= hundred),
"STAmount fail");
363 unexpected(!(zeroSt == zeroSt),
"STAmount fail");
365 unexpected((zeroSt == hundred),
"STAmount fail");
368 unexpected((one == hundred),
"STAmount fail");
369 unexpected((hundred == zeroSt),
"STAmount fail");
370 unexpected((hundred == one),
"STAmount fail");
371 unexpected(!(hundred == hundred),
"STAmount fail");
372 unexpected((zeroSt != zeroSt),
"STAmount fail");
373 unexpected(!(zeroSt != one),
"STAmount fail");
374 unexpected(!(zeroSt != hundred),
"STAmount fail");
375 unexpected(!(one != zeroSt),
"STAmount fail");
377 unexpected(!(one != hundred),
"STAmount fail");
378 unexpected(!(hundred != zeroSt),
"STAmount fail");
379 unexpected(!(hundred != one),
"STAmount fail");
380 unexpected((hundred != hundred),
"STAmount fail");
388 "STAmount multiply fail 1");
391 "STAmount multiply fail 2");
394 "STAmount multiply fail 3");
397 "STAmount multiply fail 4");
402 fail(
"STAmount divide fail");
411 "STAmount divide fail");
415 "STAmount divide fail");
419 "STAmount divide fail");
426 "STAmount setRate(getRate) fail");
430 "STAmount setRate(getRate) fail");
446 (((100ull - 14) << (64 - 8)) | 1000000000000000ull),
447 "STAmount getRate fail 1");
451 (((100ull - 16) << (64 - 8)) | 1000000000000000ull),
452 "STAmount getRate fail 2");
456 (((100ull - 14) << (64 - 8)) | 1000000000000000ull),
457 "STAmount getRate fail 3");
461 (((100ull - 16) << (64 - 8)) | 1000000000000000ull),
462 "STAmount getRate fail 4");
466 (((100ull - 14) << (64 - 8)) | 1000000000000000ull),
467 "STAmount getRate fail 5");
471 (((100ull - 16) << (64 - 8)) | 1000000000000000ull),
472 "STAmount getRate fail 6");
476 (((100ull - 14) << (64 - 8)) | 1000000000000000ull),
477 "STAmount getRate fail 7");
481 (((100ull - 16) << (64 - 8)) | 1000000000000000ull),
482 "STAmount getRate fail 8");
491 for (
int i = 0; i <= 100000; ++i)
532 BEAST_EXPECT(r == 0);
535 r =
getRate(bigValue, smallValue);
537 BEAST_EXPECT(r == 0);
556 BEAST_EXPECT(stnum.
getSType() == STI_AMOUNT);
557 BEAST_EXPECT(stnum.
getText() ==
"0");
599 std::string const expected =
"XRP and MPT must be specified as integral amount.";
600 BEAST_EXPECT(e.
what() == expected);
611 std::string const expected =
"XRP and MPT must be specified as integral amount.";
612 BEAST_EXPECT(e.
what() == expected);
624 BEAST_EXPECT(e.
what() == expected);
634 std::string const expected =
"'e' is not a number";
635 BEAST_EXPECT(e.
what() == expected);
645 std::string const expected =
"'1e' is not a number";
646 BEAST_EXPECT(e.
what() == expected);
656 std::string const expected =
"'e2' is not a number";
657 BEAST_EXPECT(e.
what() == expected);
667 std::string const expected =
"XRP may not be specified with a null Json value";
668 BEAST_EXPECT(e.
what() == expected);
675 "123456789012345678901234567890123456789012345678901234"
677 "901234567890123456789012345678901234567890123456789012"
679 "78901234567890123456789012345678901234567890");
695 std::string const expected =
"'001' is not a number";
696 BEAST_EXPECT(e.
what() == expected);
706 std::string const expected =
"'000.0' is not a number";
707 BEAST_EXPECT(e.
what() == expected);
718 std::string const expected =
"'.1' is not a number";
719 BEAST_EXPECT(e.
what() == expected);
729 std::string const expected =
"'1.' is not a number";
730 BEAST_EXPECT(e.
what() == expected);
740 std::string const expected =
"'1.e3' is not a number";
741 BEAST_EXPECT(e.
what() == expected);
749 testcase(
"STAmount to XRPAmount conversions");
754 for (
std::uint64_t drops = 100000000000000000; drops != 1; drops = drops / 10)
757 auto const s = t.xrp();
758 BEAST_EXPECT(s.drops() == drops);
774 fail(
"wrong exception");
781 testcase(
"STAmount to IOUAmount conversions");
786 for (
std::uint64_t dollars = 10000000000; dollars != 1; dollars = dollars / 10)
789 auto const s = t.iou();
790 BEAST_EXPECT(t ==
STAmount(s, usd));
791 BEAST_EXPECT(s.mantissa() == t.mantissa());
792 BEAST_EXPECT(s.exponent() == t.exponent());
806 fail(
"wrong exception");
819 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
826 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
833 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
840 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
847 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
854 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
864 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
881 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
888 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
895 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
902 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
909 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
916 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
923 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
939 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
946 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
953 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
960 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
967 BEAST_EXPECT(
canAdd(amt1, amt2) ==
true);
974 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
986 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
993 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
1000 BEAST_EXPECT(
canAdd(amt1, amt2) ==
false);
1007 testcase(
"MPT transfer rate rounding uses Number arithmetic");
1011 STAmount const largeAmount{asset, UINT64_C(1'230'000'000'000'000'000)};
1012 STAmount const scaledAmount{asset, UINT64_C(1'845'000'000'000'000'000)};
1014 auto const rules = [](
bool const mptV2) {
1021 return Rules{mptV2 ? kMptV2Features : kNoFeatures};
1024 auto const throwsOverflow = [&](
auto&& f,
bool expected =
true) {
1034 BEAST_EXPECT(threw == expected);
1076 auto const up =
mulRound(iouVal, xrpVal, usd,
true);
1077 auto const down =
mulRound(iouVal, xrpVal, usd,
false);
1078 BEAST_EXPECT(down.signum() > 0);
1079 BEAST_EXPECT(up >= down);
1090 STAmount const bigMpt{asset, UINT64_C(5'000'000'000'000'000'000)};
1091 STAmount const milli{
noIssue(), UINT64_C(1'000'000'000'000'000), -18};
1093 STAmount const tenMicro{
noIssue(), UINT64_C(1'000'000'000'000'000), -20};
1094 STAmount const usdResult{usd, UINT64_C(5'000'000'000'000'000)};
1095 XRPAmount const xrpResult{50'000'000'000'000};
1099 throwsOverflow([&] { (void)
mulRound(bigMpt, milli, usd,
true); });
1100 throwsOverflow([&] { (void)
mulRound(bigMpt, tenMicro,
xrpIssue(),
true); });
1101 throwsOverflow([&] { (void)
divRound(bigMpt, kilo, usd,
true); });
1102 throwsOverflow([&] { (void)
divRoundStrict(bigMpt, kilo, usd,
false); });
1107 BEAST_EXPECT(
mulRound(bigMpt, milli, usd,
true) == usdResult);
1108 BEAST_EXPECT(
mulRound(bigMpt, milli, usd,
false) == usdResult);
1110 BEAST_EXPECT(
divRound(bigMpt, kilo, usd,
true) == usdResult);
1111 BEAST_EXPECT(
divRoundStrict(bigMpt, kilo, usd,
false) == usdResult);
1298 int const refScale = ref.exponent();
1299 BEAST_EXPECT(refScale == -14);
1317 BEAST_EXPECT(!ref.isZeroAtScale(refScale));
1384 testcase(
"MPT operand with IOU result does not wrap negative");
1395 STAmount const funds{s, UINT64_C(480'000'000'000'000'000)};
1397 STAmount const invRate{
noIssue(), UINT64_C(5'000'000'000'000'000), -1};
1400 auto const rules = [](
bool const mptV2) {
1407 return Rules{mptV2 ? kMptV2Features : kNoFeatures};
1413 BEAST_EXPECT(
mulRoundStrict(funds, rate, usd,
false).signum() < 0);
1414 BEAST_EXPECT(
mulRound(funds, rate, usd,
false).signum() < 0);
1415 BEAST_EXPECT(
divRoundStrict(funds, invRate, usd,
false).signum() < 0);
1421 for (
bool const roundUp : {
false,
true})
1423 BEAST_EXPECT(
mulRoundStrict(funds, rate, usd, roundUp) == expected);
1424 BEAST_EXPECT(
mulRound(funds, rate, usd, roundUp) == expected);
1425 BEAST_EXPECT(
divRoundStrict(funds, invRate, usd, roundUp) == expected);
1426 BEAST_EXPECT(
divRound(funds, invRate, usd, roundUp) == expected);
1434 testcase(
"getRate with a large integral numerator");
1439 auto const rules = [](
bool const mptV2) {
1444 featureSingleAssetVault,
1447 return Rules{mptV2 ? kMptV2Features : kNoFeatures};
1453 STAmount const dust{usd, UINT64_C(1'000'000'000'000'000), -22};
1454 STAmount const largeMpt{asset, UINT64_C(184'467'440'737'095'516)};
1459 STAmount const one{usd, UINT64_C(1'000'000'000'000'000), -15};
1460 STAmount const hugeMpt{asset, UINT64_C(5'000'000'000'000'000'000)};
1461 STAmount const hugeMptRate{
noIssue(), UINT64_C(5'000'000'000'000'000), 3};
1469 STAmount const oneAndHalf{
noIssue(), UINT64_C(1'500'000'000'000'000), -15};
1470 STAmount const e18Mpt{asset, UINT64_C(1'000'000'000'000'000'000)};
1475 STAmount const hugeXrpRate{
noIssue(), UINT64_C(9'500'000'000'000'000), 1};
1483 BEAST_EXPECT(
getRate(one, hugeMpt) == 0);
1484 BEAST_EXPECT(
getRate(tiny, hugeMpt) == 0);
1485 BEAST_EXPECT(
getRate(one, hugeXrp) != 0);
1491 (void)
divide(hugeMpt, one, asset);
1497 BEAST_EXPECT(threw);
1505 BEAST_EXPECT(
getRate(tiny, hugeMpt) == 0);
1507 BEAST_EXPECT(!
divide(largeMpt, dust,
noIssue()).negative());
1509 BEAST_EXPECT(
divide(hugeMpt, one, asset) == hugeMpt);
1510 BEAST_EXPECT(
divide(maxMpt, one, asset) == maxMpt);
1512 divide(
STAmount{asset, UINT64_C(9'000'000'000'000'000'000)}, oneAndHalf, asset) ==
1513 STAmount(asset, UINT64_C(6'000'000'000'000'000'000)));
1531 testcase(
"Rounded-up MPT operand with an IOU result below the minimum");
1536 auto const rules = [](
bool const mptV2) {
1541 return Rules{mptV2 ? kMptV2Features : kNoFeatures};
1552 BEAST_EXPECT(
divRound(oneMpt, huge, usd,
true) == smallestUsd);
1560 BEAST_EXPECT(
divRound(oneMpt, huge, usd,
true) == smallestUsd);
1561 BEAST_EXPECT(
divRoundStrict(oneMpt, huge, usd,
true) == smallestUsd);
bool except(F &&f, String const &reason)
bool unexpected(Condition shouldBeFalse, String const &reason)
DEPRECATED.
void pass()
Record a successful test condition.
void fail(String const &reason, char const *file, int line)
Record a failure.
LogOs< char > log
Logging output stream.
TestcaseT testcase
Memberspace for declaring test cases.
RAII class to set and restore the current transaction rules.
A currency issued by an account.
Number is a floating point type that can represent a wide range of values.
Rules controlling protocol behavior.
static STAmount roundSelf(STAmount const &amount)
void testSetValue(std::string const &value, Issue const &issue, bool success=true)
void testCanSubtractXRP()
void run() override
Runs the suite.
void testMPTRateRounding()
void testCanSubtractMPT()
void mulTest(int a, int b)
void testCanSubtractIOU()
static STAmount serializeAndDeserialize(STAmount const &s)
void testNativeCurrency()
void testMPTOperandIOUResult()
void roundTest(int n, int d, int m)
void testCustomCurrency()
void testMPTRoundUpUnderflow()
constexpr TIss const & get() const
std::string getFullText() const override
void add(Serializer &s) const override
std::uint64_t mantissa() const noexcept
std::string getText() const override
static constexpr int kMinOffset
SerializedTypeID getSType() const override
bool negative() const noexcept
bool isDefault() const override
bool native() const noexcept
Asset const & asset() const
int exponent() const noexcept
bool isZeroAtScale(int scale) const
Checks if this amount evaluates to zero when constrained to a specific accounting scale.
static constexpr std::uint64_t kMinValue
static constexpr std::uint64_t kMaxValue
static constexpr std::uint64_t kMaxNative
static constexpr int kMaxOffset
STAmount const & value() const noexcept
Slice slice() const noexcept
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
STAmount divide(STAmount const &amount, Rate const &rate)
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
STAmount mulRoundStrict(STAmount const &v1, STAmount const &v2, Asset const &asset, bool roundUp)
BaseUInt< 160, detail::CurrencyTag > Currency
Currency is a hash representing a specific currency.
STAmount amountFromString(Asset const &asset, std::string const &amount)
bool toCurrency(Currency &, std::string const &)
Tries to convert a string to a Currency, returns true on success.
STAmount divRound(STAmount const &v1, STAmount const &v2, Asset const &asset, bool roundUp)
std::string to_string(BaseUInt< Bits, Tag > const &a)
bool canAdd(STAmount const &amt1, STAmount const &amt2)
Safely checks if two STAmount values can be added without overflow, underflow, or precision loss.
STAmount amountFromQuality(std::uint64_t rate)
Rate transferRate(ReadView const &view, AccountID const &issuer)
Returns IOU issuer transfer fee as Rate.
STAmount multiplyRound(STAmount const &amount, Rate const &rate, bool roundUp)
std::uint64_t getRate(STAmount const &offerOut, STAmount const &offerIn)
STAmount amountFromJson(SField const &name, json::Value const &v)
MPTID makeMptID(std::uint32_t const sequence, AccountID const &account)
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
STAmount mulRound(STAmount const &v1, STAmount const &v2, Asset const &asset, bool roundUp)
bool canSubtract(STAmount const &amt1, STAmount const &amt2)
Determines if it is safe to subtract one STAmount from another.
STAmount divRoundStrict(STAmount const &v1, STAmount const &v2, Asset const &asset, bool roundUp)
Issue const & noIssue()
Returns an asset specifier that represents no account and currency.
STAmount multiply(STAmount const &amount, Number const &frac, Number::RoundingMode rm)
constexpr std::uint64_t kMaxMpTokenAmount
The maximum amount of MPTokenIssuance.
STAmount divideRound(STAmount const &amount, Rate const &rate, bool roundUp)
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
Represents a transfer rate.