xrpld
Loading...
Searching...
No Matches
GetAggregatePrice_test.cpp
1#include <test/jtx/Account.h>
2#include <test/jtx/Env.h>
3#include <test/jtx/Oracle.h>
4#include <test/jtx/amount.h>
5
6#include <xrpld/app/ledger/OpenLedger.h>
7
8#include <xrpl/basics/Number.h>
9#include <xrpl/basics/base_uint.h>
10#include <xrpl/basics/random.h>
11#include <xrpl/beast/unit_test/suite.h>
12#include <xrpl/beast/utility/Journal.h>
13#include <xrpl/core/ServiceRegistry.h>
14#include <xrpl/ledger/OpenView.h>
15#include <xrpl/protocol/ErrorCodes.h>
16#include <xrpl/protocol/Feature.h>
17#include <xrpl/protocol/Indexes.h>
18#include <xrpl/protocol/SField.h>
19#include <xrpl/protocol/jss.h>
20
21#include <cstdint>
22#include <memory>
23#include <optional>
24#include <string>
25#include <vector>
26
28
30{
31public:
32 void
34 {
35 testcase("Errors");
36 using namespace jtx;
37 Account const owner{"owner"};
38 Account const some{"some"};
39 static OraclesData kOracles = {{owner, 1}};
40
41 {
42 Env env(*this);
43 auto const baseFee = env.current()->fees().base;
44 // missing base_asset
45 auto ret = Oracle::aggregatePrice(env, std::nullopt, "USD", kOracles);
46 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
47 BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
48 BEAST_EXPECT(ret[jss::error_message].asString() == "Missing field 'base_asset'.");
49
50 // missing quote_asset
51 ret = Oracle::aggregatePrice(env, "XRP", std::nullopt, kOracles);
52 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
53 BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
54 BEAST_EXPECT(ret[jss::error_message].asString() == "Missing field 'quote_asset'.");
55
56 // invalid base_asset, quote_asset
57 std::vector<AnyValue> const invalidAsset = {
59 1,
60 -1,
61 1.2,
62 "",
63 "invalid",
64 "a",
65 "ab",
66 "A",
67 "AB",
68 "ABCD",
69 "010101",
70 "012345678901234567890123456789012345678",
71 "012345678901234567890123456789012345678G",
72 };
73 for (auto const& v : invalidAsset)
74 {
75 ret = Oracle::aggregatePrice(env, "USD", v, kOracles);
76 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
77 BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
78 BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
79 ret = Oracle::aggregatePrice(env, v, "USD", kOracles);
80 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
81 BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
82 BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
83 ret = Oracle::aggregatePrice(env, v, v, kOracles);
84 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
85 BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
86 BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
87 }
88
89 // missing oracles array
90 ret = Oracle::aggregatePrice(env, "XRP", "USD");
91 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
92 BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
93 BEAST_EXPECT(ret[jss::error_message].asString() == "Missing field 'oracles'.");
94
95 // empty oracles array
96 ret = Oracle::aggregatePrice(env, "XRP", "USD", OraclesData{});
97 BEAST_EXPECT(ret[jss::error].asString() == "oracleMalformed");
98 BEAST_EXPECT(ret[jss::error_code] == RpcOracleMalformed);
99 BEAST_EXPECT(ret[jss::error_message].asString() == "Oracle request is malformed.");
100
101 // no token pairs found
102 ret = Oracle::aggregatePrice(env, "YAN", "USD", kOracles);
103 BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
104 BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
105 BEAST_EXPECT(
106 ret[jss::error_message].asString() == "The requested object was not found.");
107
108 // invalid oracle document id
109 // id doesn't exist
110 ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, 2}}});
111 BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
112 BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
113 BEAST_EXPECT(
114 ret[jss::error_message].asString() == "The requested object was not found.");
115 // invalid values
116 std::vector<AnyValue> const invalidDocument = {kNoneTag, 1.2, -1, "", "none", "1.2"};
117 for (auto const& v : invalidDocument)
118 {
119 ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, v}}});
120 json::Value jv;
121 toJson(jv, v);
122 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
123 BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
124 BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
125 }
126 // missing document id
127 ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, std::nullopt}}});
128 BEAST_EXPECT(ret[jss::error].asString() == "oracleMalformed");
129 BEAST_EXPECT(ret[jss::error_code] == RpcOracleMalformed);
130 BEAST_EXPECT(ret[jss::error_message].asString() == "Oracle request is malformed.");
131
132 // invalid owner
133 ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{some, 1}}});
134 BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
135 BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
136 BEAST_EXPECT(
137 ret[jss::error_message].asString() == "The requested object was not found.");
138 // missing account
139 ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{std::nullopt, 1}}});
140 BEAST_EXPECT(ret[jss::error].asString() == "oracleMalformed");
141 BEAST_EXPECT(ret[jss::error_code] == RpcOracleMalformed);
142 BEAST_EXPECT(ret[jss::error_message].asString() == "Oracle request is malformed.");
143
144 // oracles have wrong asset pair
145 env.fund(XRP(1'000), owner);
146 Oracle const oracle(
147 env,
148 {
149 .owner = owner,
150 .series = {{"XRP", "EUR", 740, 1}},
151 .fee = static_cast<int>(baseFee.drops()),
152 });
153 ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, oracle.documentID()}}});
154 BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
155 BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
156 BEAST_EXPECT(
157 ret[jss::error_message].asString() == "The requested object was not found.");
158
159 // invalid trim value
160 std::vector<AnyValue> const invalidTrim = {kNoneTag, 0, 26, -1, 1.2, "", "none", "1.2"};
161 for (auto const& v : invalidTrim)
162 {
163 ret =
164 Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, oracle.documentID()}}}, v);
165 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
166 BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
167 BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
168 }
169
170 // invalid time threshold value
171 std::vector<AnyValue> const invalidTime = {kNoneTag, -1, 1.2, "", "none", "1.2"};
172 for (auto const& v : invalidTime)
173 {
175 env, "XRP", "USD", {{{owner, oracle.documentID()}}}, std::nullopt, v);
176 BEAST_EXPECT(ret[jss::error].asString() == "invalidParams");
177 BEAST_EXPECT(ret[jss::error_code] == RpcInvalidParams);
178 BEAST_EXPECT(ret[jss::error_message].asString() == "Invalid parameters.");
179 }
180 }
181
182 // too many oracles
183 {
184 Env env(*this);
185 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
186
187 OraclesData oracles;
188 for (int i = 0; i < 201; ++i)
189 {
190 Account const owner(std::to_string(i));
191 env.fund(XRP(1'000), owner);
192 Oracle const oracle(env, {.owner = owner, .documentID = i, .fee = baseFee});
193 oracles.emplace_back(owner, oracle.documentID());
194 }
195 auto const ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles);
196 BEAST_EXPECT(ret[jss::error].asString() == "oracleMalformed");
197 BEAST_EXPECT(ret[jss::error_code] == RpcOracleMalformed);
198 BEAST_EXPECT(ret[jss::error_message].asString() == "Oracle request is malformed.");
199 }
200 }
201
202 void
204 {
205 testcase("RPC");
206 using namespace jtx;
207
208 auto const prep = [&](Env& env, auto& oracles) {
209 oracles.reserve(10);
210 for (int i = 0; i < 10; ++i)
211 {
212 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
213
214 Account const owner{std::to_string(i)};
215 env.fund(XRP(1'000), owner);
216 Oracle const oracle(
217 env,
218 {
219 .owner = owner,
220 .documentID = randInt<std::uint32_t>(),
221 .series = {{"XRP", "USD", 740 + i, 1}, {"XRP", "EUR", 740, 1}},
222 .fee = baseFee,
223 });
224 oracles.emplace_back(owner, oracle.documentID());
225 }
226 };
227
228 // Aggregate data set includes all price oracle instances, no trimming
229 // or time threshold
230 {
231 auto const all = testableAmendments();
232 for (auto const& feats : {all - featureSingleAssetVault - featureLendingProtocol, all})
233 {
234 for (auto const mantissaSize : MantissaRange::getAllScales())
235 {
236 // Regardless of the features enabled, RPC is controlled by
237 // the global mantissa size. And since it's a thread-local,
238 // overriding it locally won't make a difference either.
239 // This will mean all RPC will use the default of "large".
240 NumberMantissaScaleGuard const mg(mantissaSize);
241
242 Env env(*this, feats);
243 OraclesData oracles;
244 prep(env, oracles);
245 // entire and trimmed stats
246 auto ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles);
247 BEAST_EXPECT(ret[jss::entire_set][jss::mean] == "74.45");
248 BEAST_EXPECT(ret[jss::entire_set][jss::size].asUInt() == 10);
249 // Short: 0.3027650354097492
250 BEAST_EXPECTS(
251 ret[jss::entire_set][jss::standard_deviation] == "0.3027650354097491666",
252 ret[jss::entire_set][jss::standard_deviation].asString());
253 BEAST_EXPECT(ret[jss::median] == "74.45");
254 BEAST_EXPECT(ret[jss::time] == 946694900);
255 }
256 }
257 }
258
259 // Aggregate data set includes all price oracle instances
260 {
261 Env env(*this);
262 OraclesData oracles;
263 prep(env, oracles);
264 // entire and trimmed stats
265 auto ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles, 20, 100);
266 BEAST_EXPECT(ret[jss::entire_set][jss::mean] == "74.45");
267 BEAST_EXPECT(ret[jss::entire_set][jss::size].asUInt() == 10);
268 // Short: "0.3027650354097492",
269 BEAST_EXPECTS(
270 ret[jss::entire_set][jss::standard_deviation] == "0.3027650354097491666",
271 ret[jss::entire_set][jss::standard_deviation].asString());
272 BEAST_EXPECT(ret[jss::median] == "74.45");
273 BEAST_EXPECT(ret[jss::trimmed_set][jss::mean] == "74.45");
274 BEAST_EXPECT(ret[jss::trimmed_set][jss::size].asUInt() == 6);
275 // Short: "0.187082869338697",
276 BEAST_EXPECTS(
277 ret[jss::trimmed_set][jss::standard_deviation] == "0.1870828693386970693",
278 ret[jss::trimmed_set][jss::standard_deviation].asString());
279 BEAST_EXPECT(ret[jss::time] == 946694900);
280 }
281
282 // A reduced dataset, as some price oracles have data beyond three
283 // updated ledgers
284 {
285 Env env(*this);
286 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
287
288 OraclesData oracles;
289 prep(env, oracles);
290 for (int i = 0; i < 3; ++i)
291 {
293 env,
294 {
295 .owner = oracles[i].first,
296 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
297 .documentID = asUInt(*oracles[i].second),
298 .fee = baseFee,
299 },
300 false);
301 // push XRP/USD by more than three ledgers, so this price
302 // oracle is not included in the dataset
303 oracle.set(UpdateArg{.series = {{"XRP", "EUR", 740, 1}}, .fee = baseFee});
304 oracle.set(UpdateArg{.series = {{"XRP", "EUR", 740, 1}}, .fee = baseFee});
305 oracle.set(UpdateArg{.series = {{"XRP", "EUR", 740, 1}}, .fee = baseFee});
306 }
307 for (int i = 3; i < 6; ++i)
308 {
310 env,
311 {
312 .owner = oracles[i].first,
313 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
314 .documentID = asUInt(*oracles[i].second),
315 .fee = baseFee,
316 },
317 false);
318 // push XRP/USD by two ledgers, so this price
319 // is included in the dataset
320 oracle.set(UpdateArg{.series = {{"XRP", "EUR", 740, 1}}, .fee = baseFee});
321 oracle.set(UpdateArg{.series = {{"XRP", "EUR", 740, 1}}, .fee = baseFee});
322 }
323
324 // entire and trimmed stats
325 auto ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles, 20, "200");
326 BEAST_EXPECT(ret[jss::entire_set][jss::mean] == "74.6");
327 BEAST_EXPECT(ret[jss::entire_set][jss::size].asUInt() == 7);
328 // Short: 0.2160246899469287
329 BEAST_EXPECTS(
330 ret[jss::entire_set][jss::standard_deviation] == "0.2160246899469286744",
331 ret[jss::entire_set][jss::standard_deviation].asString());
332 BEAST_EXPECT(ret[jss::median] == "74.6");
333 BEAST_EXPECT(ret[jss::trimmed_set][jss::mean] == "74.6");
334 BEAST_EXPECT(ret[jss::trimmed_set][jss::size].asUInt() == 5);
335 // Short: 0.158113883008419
336 BEAST_EXPECTS(
337 ret[jss::trimmed_set][jss::standard_deviation] == "0.1581138830084189666",
338 ret[jss::trimmed_set][jss::standard_deviation].asString());
339 BEAST_EXPECT(ret[jss::time] == 946694900);
340 }
341
342 // Reduced data set because of the time threshold
343 {
344 Env env(*this);
345 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
346
347 OraclesData oracles;
348 prep(env, oracles);
349 for (auto& oracleData : oracles)
350 {
352 env,
353 {
354 .owner = oracleData.first,
355 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
356 .documentID = asUInt(*oracleData.second),
357 .fee = baseFee,
358 },
359 false);
360 // push XRP/USD by two ledgers, so this price
361 // is included in the dataset
362 oracle.set(UpdateArg{.series = {{"XRP", "USD", 740, 1}}, .fee = baseFee});
363 }
364
365 // entire stats only, limit lastUpdateTime to {200, 125}
366 auto ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles, std::nullopt, 75);
367 BEAST_EXPECT(ret[jss::entire_set][jss::mean] == "74");
368 BEAST_EXPECT(ret[jss::entire_set][jss::size].asUInt() == 8);
369 BEAST_EXPECT(ret[jss::entire_set][jss::standard_deviation] == "0");
370 BEAST_EXPECT(ret[jss::median] == "74");
371 BEAST_EXPECT(ret[jss::time] == 946695000);
372 }
373
374 // Duplicate oracle entries should be deduplicated.
375 // Two separate oracles with different prices give size=2.
376 // Listing the first oracle twice in the query must not
377 // inflate the size to 3.
378 {
379 Env env(*this);
380 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
381
382 Account const owner1{"owner1"};
383 Account const owner2{"owner2"};
384 env.fund(XRP(1'000), owner1);
385 env.fund(XRP(1'000), owner2);
386 Oracle const oracle1(
387 env, {.owner = owner1, .series = {{"XRP", "USD", 740, 1}}, .fee = baseFee});
388 Oracle const oracle2(
389 env, {.owner = owner2, .series = {{"XRP", "USD", 840, 1}}, .fee = baseFee});
390
391 // Query with both oracles listed once
392 OraclesData const single = {
393 {owner1, oracle1.documentID()},
394 {owner2, oracle2.documentID()},
395 };
396 auto const retSingle = Oracle::aggregatePrice(env, "XRP", "USD", single);
397
398 // Query with oracle1 listed twice
399 OraclesData const duplicated = {
400 {owner1, oracle1.documentID()},
401 {owner1, oracle1.documentID()},
402 {owner2, oracle2.documentID()},
403 };
404 auto const retDup = Oracle::aggregatePrice(env, "XRP", "USD", duplicated);
405
406 // Results should be identical - duplicates must not be
407 // double-counted
408 BEAST_EXPECT(
409 retSingle[jss::entire_set][jss::size] == retDup[jss::entire_set][jss::size]);
410 BEAST_EXPECT(retDup[jss::entire_set][jss::size].asUInt() == 2);
411 BEAST_EXPECT(
412 retSingle[jss::entire_set][jss::mean] == retDup[jss::entire_set][jss::mean]);
413 BEAST_EXPECT(
414 retSingle[jss::entire_set][jss::standard_deviation] ==
415 retDup[jss::entire_set][jss::standard_deviation]);
416 BEAST_EXPECT(retSingle[jss::median] == retDup[jss::median]);
417 }
418 }
419
420 void
422 {
423 testcase("Null txRead metadata");
424 using namespace jtx;
425
426 // Verify that iteratePriceData handles a null txRead result
427 // gracefully (returns early) rather than crashing with a
428 // nullptr dereference. This simulates local data corruption
429 // where a transaction referenced by sfPreviousTxnID is missing
430 // from the ledger's transaction map.
431 Env env(*this);
432 auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
433
434 Account const owner{"owner"};
435 env.fund(XRP(1'000), owner);
436
437 // Create oracle with XRP/USD and XRP/EUR
439 env,
440 {
441 .owner = owner,
442 .series = {{"XRP", "USD", 740, 1}, {"XRP", "EUR", 840, 1}},
443 .fee = baseFee,
444 });
445
446 // Update oracle to only have XRP/EUR, pushing XRP/USD into
447 // history. iteratePriceData will need to read historical tx
448 // metadata to find the XRP/USD price.
449 oracle.set(UpdateArg{.series = {{"XRP", "EUR", 850, 1}}, .fee = baseFee});
450
451 OraclesData const oracles{{owner, oracle.documentID()}};
452
453 // Precondition: with an uncorrupted oracle, the historical
454 // traversal must succeed and produce a price for XRP/USD.
455 // This proves the test reaches iteratePriceData's history
456 // path; without it, a future change that breaks the setup
457 // could turn the post-corruption assertion into a vacuous
458 // pass (objectNotFound is reachable from many unrelated
459 // code paths).
460 {
461 auto const ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles);
462 BEAST_EXPECT(!ret.isMember(jss::error));
463 BEAST_EXPECT(ret.isMember(jss::median));
464 }
465
466 // Simulate data corruption: modify the oracle SLE in the open
467 // ledger to have a bogus sfPreviousTxnID that doesn't exist in
468 // any ledger. sfPreviousTxnLgrSeq still points to a valid closed
469 // ledger, so getLedgerBySeq succeeds but txRead returns null.
470 auto const oracleKeylet = keylet::oracle(owner, oracle.documentID());
471 UInt256 const bogusTxnID{0xABCABCAB};
472 bool const modified = env.app().getOpenLedger().modify(
473 [&oracleKeylet, &bogusTxnID](OpenView& view, beast::Journal) -> bool {
474 auto const sle = view.read(oracleKeylet);
475 if (!sle)
476 return false;
477 auto const replacement = std::make_shared<SLE>(*sle, sle->key());
478 replacement->setFieldH256(sfPreviousTxnID, bogusTxnID);
479 view.rawReplace(replacement);
480 return true;
481 });
482
483 // Confirm the injection actually took effect: modify must
484 // report success, and re-reading the SLE must show the
485 // bogus hash. Otherwise the failure-mode assertion below
486 // would not be exercising the null-txRead path at all.
487 BEAST_EXPECT(modified);
488 if (auto const sle = env.current()->read(oracleKeylet); BEAST_EXPECT(sle))
489 BEAST_EXPECT(sle->getFieldH256(sfPreviousTxnID) == bogusTxnID);
490
491 // Query for XRP/USD using the "current" (open) ledger.
492 // The oracle SLE now has a bogus sfPreviousTxnID. The current
493 // oracle only has EUR, so iteratePriceData will try to read
494 // history. txRead returns null for the bogus hash, and the
495 // null check should cause a graceful early return instead of
496 // a nullptr dereference.
497 auto const ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles);
498 BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
499 BEAST_EXPECT(ret[jss::error_code] == RpcObjectNotFound);
500 BEAST_EXPECT(ret[jss::error_message].asString() == "The requested object was not found.");
501 }
502
503 void
504 run() override
505 {
506 testErrors();
507 testRpc();
509 }
510};
511
512BEAST_DEFINE_TESTSUITE(GetAggregatePrice, rpc, xrpl);
513
514} // namespace xrpl::test::jtx::oracle
A generic endpoint for log messages.
Definition Journal.h:44
A testsuite class.
Definition suite.h:52
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
Sets the new scale and restores the old scale when it leaves scope.
Definition Number.h:967
bool modify(ModifyType const &f)
Modify the open ledger.
Writable ledger view that accumulates state and tx changes.
Definition OpenView.h:59
void rawReplace(SLE::Ref sle) override
Unconditionally replace a state item.
Definition OpenView.cpp:246
SLE::const_pointer read(Keylet const &k) const override
Return the state item associated with a key.
Definition OpenView.cpp:170
virtual OpenLedger & getOpenLedger()=0
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
A transaction testing environment.
Definition Env.h:161
Application & app()
Definition Env.h:300
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
Oracle class facilitates unit-testing of the Price Oracle feature.
static json::Value aggregatePrice(Env &env, std::optional< AnyValue > const &baseAsset, std::optional< AnyValue > const &quoteAsset, std::optional< OraclesData > const &oracles=std::nullopt, std::optional< AnyValue > const &trim=std::nullopt, std::optional< AnyValue > const &timeThreshold=std::nullopt)
Definition Oracle.cpp:162
T emplace_back(T... args)
T make_shared(T... args)
Keylet oracle(AccountID const &account, std::uint32_t const documentID) noexcept
Definition Indexes.cpp:535
The api_version numbers this server serves.
Definition ApiVersion.h:26
std::uint32_t asUInt(AnyValue const &v)
Definition Oracle.cpp:400
std::vector< std::pair< std::optional< Account >, std::optional< AnyValue > > > OraclesData
constexpr char const * kNoneTag
void toJson(json::Value &jv, AnyValue const &v)
Definition Oracle.cpp:370
BEAST_DEFINE_TESTSUITE(Oracle, app, xrpl)
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
FeatureBitset testableAmendments()
Definition Env.h:92
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ RpcOracleMalformed
Definition ErrorCodes.h:132
@ RpcObjectNotFound
Definition ErrorCodes.h:126
@ RpcInvalidParams
Definition ErrorCodes.h:67
BaseUInt< 256 > UInt256
Definition base_uint.h:581
static std::set< MantissaScale > const & getAllScales()
Definition Number.h:178
T to_string(T... args)