xrpld
Loading...
Searching...
No Matches
VaultRPC_test.cpp
1#include <test/app/vault/VaultTestBase.h>
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/amount.h>
5#include <test/jtx/pay.h>
6#include <test/jtx/vault.h>
7
8#include <xrpl/basics/base_uint.h>
9#include <xrpl/basics/chrono.h>
10#include <xrpl/basics/strHex.h>
11#include <xrpl/beast/unit_test/suite.h>
12#include <xrpl/beast/utility/Zero.h>
13#include <xrpl/json/json_forwards.h>
14#include <xrpl/json/json_value.h>
15#include <xrpl/json/to_string.h>
16#include <xrpl/protocol/AccountID.h>
17#include <xrpl/protocol/Asset.h>
18#include <xrpl/protocol/ErrorCodes.h>
19#include <xrpl/protocol/Issue.h>
20#include <xrpl/protocol/Keylet.h>
21#include <xrpl/protocol/LedgerFormats.h>
22#include <xrpl/protocol/Protocol.h>
23#include <xrpl/protocol/SField.h>
24#include <xrpl/protocol/jss.h>
25
26#include <chrono>
27#include <memory>
28#include <string>
29#include <tuple>
30#include <utility>
31
32namespace xrpl {
33
35{
36private:
37 void
39 {
40 using namespace test::jtx;
41
42 testcase("RPC");
43 Env env{*this, testableAmendments()};
44 Account const owner{"owner"};
45 Account const issuer{"issuer"};
46 Vault const vault{env};
47 env.fund(XRP(1000), issuer, owner);
48 env.close();
49
50 PrettyAsset const asset = issuer["IOU"];
51 env.trust(asset(1000), owner);
52 env(pay(issuer, owner, asset(200)));
53 env.close();
54
55 auto const sequence = env.seq(owner);
56 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
57 env(tx);
58 env.close();
59
60 // Set some fields
61 {
62 auto const tx1 =
63 vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(50)});
64 env(tx1);
65
66 auto tx2 = vault.set({.owner = owner, .id = keylet.key});
67 tx2[sfAssetsMaximum] = asset(1000).number();
68 env(tx2);
69 env.close();
70 }
71
72 auto const sleVault = [&env, keylet = keylet, this] {
73 auto const vault = env.le(keylet);
74 BEAST_EXPECT(vault != nullptr);
75 return vault;
76 }();
77
78 auto const check = [&, keylet = keylet, sle = sleVault, this](
79 json::Value const& vault,
80 json::Value const& issuance = json::ValueType::Null) {
81 BEAST_EXPECT(vault.isObject());
82
83 static constexpr auto kCheckString =
84 [](auto& node, SField const& field, std::string v) -> bool {
85 return node.isMember(field.fieldName) && node[field.fieldName].isString() &&
86 node[field.fieldName] == v;
87 };
88 static constexpr auto kCheckObject =
89 [](auto& node, SField const& field, json::Value v) -> bool {
90 return node.isMember(field.fieldName) && node[field.fieldName].isObject() &&
91 node[field.fieldName] == v;
92 };
93 static constexpr auto kCheckInt = [](auto& node, SField const& field, int v) -> bool {
94 return node.isMember(field.fieldName) &&
95 ((node[field.fieldName].isInt() && node[field.fieldName] == json::Int(v)) ||
96 (node[field.fieldName].isUInt() && node[field.fieldName] == json::UInt(v)));
97 };
98
99 BEAST_EXPECT(vault["LedgerEntryType"].asString() == "Vault");
100 BEAST_EXPECT(vault[jss::index].asString() == strHex(keylet.key));
101 BEAST_EXPECT(kCheckInt(vault, sfFlags, 0));
102 // Ignore all other standard fields, this test doesn't care
103
104 BEAST_EXPECT(kCheckString(vault, sfAccount, toBase58(sle->at(sfAccount))));
105 BEAST_EXPECT(kCheckObject(vault, sfAsset, toJson(sle->at(sfAsset))));
106 BEAST_EXPECT(kCheckString(vault, sfAssetsAvailable, "50"));
107 BEAST_EXPECT(kCheckString(vault, sfAssetsMaximum, "1000"));
108 BEAST_EXPECT(kCheckString(vault, sfAssetsTotal, "50"));
109 BEAST_EXPECT(!vault.isMember(sfLossUnrealized.getJsonName()));
110
111 auto const strShareID = strHex(sle->at(sfShareMPTID));
112 BEAST_EXPECT(kCheckString(vault, sfShareMPTID, strShareID));
113 BEAST_EXPECT(kCheckString(vault, sfOwner, toBase58(owner.id())));
114 BEAST_EXPECT(kCheckInt(vault, sfSequence, sequence));
115 BEAST_EXPECT(kCheckInt(vault, sfWithdrawalPolicy, kVaultStrategyFirstComeFirstServe));
116
117 if (issuance.isObject())
118 {
119 BEAST_EXPECT(issuance["LedgerEntryType"].asString() == "MPTokenIssuance");
120 BEAST_EXPECT(issuance[jss::mpt_issuance_id].asString() == strShareID);
121 BEAST_EXPECT(kCheckInt(issuance, sfSequence, 1));
122 BEAST_EXPECT(kCheckInt(
123 issuance, sfFlags, int(lsfMPTCanEscrow | lsfMPTCanTrade | lsfMPTCanTransfer)));
124 BEAST_EXPECT(kCheckString(issuance, sfOutstandingAmount, "50000000"));
125 }
126 };
127
128 // An error response must carry a registered token together with the matching code and
129 // message, so that clients dispatching on either of them reach the same conclusion.
130 auto const checkError = [this](
131 json::Value const& result,
132 std::string const& token,
133 ErrorCodeI const code,
134 std::string const& message) {
135 BEAST_EXPECT(result[jss::error].asString() == token);
136 BEAST_EXPECT(result[jss::error_code].asInt() == code);
137 BEAST_EXPECT(result[jss::error_message].asString() == message);
138 };
139
140 std::string const badSeqMessage = "Invalid field 'seq', not a positive 32-bit integer.";
141 std::string const badFieldsMessage =
142 "Must specify either 'vault_id' or both 'owner' and 'seq'.";
143
144 {
145 testcase("RPC ledger_entry selected by key");
146 json::Value jvParams;
147 jvParams[jss::ledger_index] = jss::validated;
148 jvParams[jss::vault] = strHex(keylet.key);
149 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
150
151 BEAST_EXPECT(!jvVault[jss::result].isMember(jss::error));
152 BEAST_EXPECT(jvVault[jss::result].isMember(jss::node));
153 check(jvVault[jss::result][jss::node]);
154 }
155
156 {
157 testcase("RPC ledger_entry selected by owner and seq");
158 json::Value jvParams;
159 jvParams[jss::ledger_index] = jss::validated;
160 jvParams[jss::vault][jss::owner] = owner.human();
161 jvParams[jss::vault][jss::seq] = sequence;
162 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
163
164 BEAST_EXPECT(!jvVault[jss::result].isMember(jss::error));
165 BEAST_EXPECT(jvVault[jss::result].isMember(jss::node));
166 check(jvVault[jss::result][jss::node]);
167 }
168
169 {
170 testcase("RPC ledger_entry cannot find vault by key");
171 json::Value jvParams;
172 jvParams[jss::ledger_index] = jss::validated;
173 jvParams[jss::vault] = to_string(UInt256(42));
174 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
175 checkError(jvVault[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
176 }
177
178 {
179 testcase("RPC ledger_entry cannot find vault by owner and seq");
180 json::Value jvParams;
181 jvParams[jss::ledger_index] = jss::validated;
182 jvParams[jss::vault][jss::owner] = issuer.human();
183 jvParams[jss::vault][jss::seq] = 1'000'000;
184 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
185 checkError(jvVault[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
186 }
187
188 {
189 testcase("RPC ledger_entry malformed key");
190 json::Value jvParams;
191 jvParams[jss::ledger_index] = jss::validated;
192 jvParams[jss::vault] = 42;
193 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
194 checkError(
195 jvVault[jss::result],
196 "malformedRequest",
198 "Invalid field 'vault', not hex string or object.");
199 }
200
201 {
202 testcase("RPC ledger_entry malformed owner");
203 json::Value jvParams;
204 jvParams[jss::ledger_index] = jss::validated;
205 jvParams[jss::vault][jss::owner] = 42;
206 jvParams[jss::vault][jss::seq] = sequence;
207 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
208 checkError(
209 jvVault[jss::result],
210 "malformedOwner",
212 "Invalid field 'owner', not AccountID.");
213 }
214
215 {
216 testcase("RPC ledger_entry malformed seq");
217 json::Value jvParams;
218 jvParams[jss::ledger_index] = jss::validated;
219 jvParams[jss::vault][jss::owner] = issuer.human();
220 jvParams[jss::vault][jss::seq] = "foo";
221 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
222 checkError(
223 jvVault[jss::result],
224 "malformedRequest",
226 "Invalid field 'seq', not number.");
227 }
228
229 {
230 testcase("RPC ledger_entry negative seq");
231 json::Value jvParams;
232 jvParams[jss::ledger_index] = jss::validated;
233 jvParams[jss::vault][jss::owner] = issuer.human();
234 jvParams[jss::vault][jss::seq] = -1;
235 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
236 checkError(
237 jvVault[jss::result],
238 "malformedRequest",
240 "Invalid field 'seq', not number.");
241 }
242
243 {
244 testcase("RPC ledger_entry oversized seq");
245 json::Value jvParams;
246 jvParams[jss::ledger_index] = jss::validated;
247 jvParams[jss::vault][jss::owner] = issuer.human();
248 jvParams[jss::vault][jss::seq] = 1e20;
249 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
250 checkError(
251 jvVault[jss::result],
252 "malformedRequest",
254 "Invalid field 'seq', not number.");
255 }
256
257 {
258 testcase("RPC ledger_entry bool seq");
259 json::Value jvParams;
260 jvParams[jss::ledger_index] = jss::validated;
261 jvParams[jss::vault][jss::owner] = issuer.human();
262 jvParams[jss::vault][jss::seq] = true;
263 auto jvVault = env.rpc("json", "ledger_entry", to_string(jvParams));
264 checkError(
265 jvVault[jss::result],
266 "malformedRequest",
268 "Invalid field 'seq', not number.");
269 }
270
271 {
272 testcase("RPC account_objects");
273
274 json::Value jvParams;
275 jvParams[jss::account] = owner.human();
276 jvParams[jss::type] = jss::vault;
277 auto jv = env.rpc("json", "account_objects", to_string(jvParams))[jss::result];
278
279 BEAST_EXPECT(jv[jss::account_objects].size() == 1);
280 check(jv[jss::account_objects][0u]);
281 }
282
283 {
284 testcase("RPC ledger_data");
285
286 json::Value jvParams;
287 jvParams[jss::ledger_index] = jss::validated;
288 jvParams[jss::binary] = false;
289 jvParams[jss::type] = jss::vault;
290 json::Value jv = env.rpc("json", "ledger_data", to_string(jvParams));
291 BEAST_EXPECT(jv[jss::result][jss::state].size() == 1);
292 check(jv[jss::result][jss::state][0u]);
293 }
294
295 {
296 testcase("RPC vault_info command line");
297 json::Value jv = env.rpc("vault_info", strHex(keylet.key), "validated");
298
299 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
300 BEAST_EXPECT(jv[jss::result].isMember(jss::vault));
301 check(jv[jss::result][jss::vault], jv[jss::result][jss::vault][jss::shares]);
302 }
303
304 {
305 testcase("RPC vault_info json");
306 json::Value jvParams;
307 jvParams[jss::ledger_index] = jss::validated;
308 jvParams[jss::vault_id] = strHex(keylet.key);
309 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
310
311 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
312 BEAST_EXPECT(jv[jss::result].isMember(jss::vault));
313 check(jv[jss::result][jss::vault], jv[jss::result][jss::vault][jss::shares]);
314 }
315
316 {
317 testcase("RPC vault_info invalid vault_id");
318 json::Value jvParams;
319 jvParams[jss::ledger_index] = jss::validated;
320 jvParams[jss::vault_id] = "foobar";
321 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
322 checkError(
323 jv[jss::result],
324 "invalidParams",
326 "Invalid field 'vault_id', not hex string.");
327 }
328
329 {
330 testcase("RPC vault_info json numeric vault_id");
331 json::Value jvParams;
332 jvParams[jss::ledger_index] = jss::validated;
333 jvParams[jss::vault_id] = 0;
334 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
335 checkError(
336 jv[jss::result],
337 "invalidParams",
339 "Invalid field 'vault_id', not hex string.");
340 }
341
342 {
343 testcase("RPC vault_info json object vault_id");
344 json::Value jvParams;
345 jvParams[jss::ledger_index] = jss::validated;
346 jvParams[jss::vault_id] = json::Value(json::ValueType::Object);
347 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
348 checkError(
349 jv[jss::result],
350 "invalidParams",
352 "Invalid field 'vault_id', not hex string.");
353 }
354
355 {
356 // An all-zero key is a well-formed request for a vault that cannot exist, not a
357 // malformed one. parseHex accepts both the padded form and the short "0".
358 testcase("RPC vault_info json all zero vault_id");
359 json::Value jvParams;
360 jvParams[jss::ledger_index] = jss::validated;
361 jvParams[jss::vault_id] = strHex(UInt256(beast::kZero));
362 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
363 checkError(jv[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
364 }
365
366 {
367 testcase("RPC vault_info json short zero vault_id");
368 json::Value jvParams;
369 jvParams[jss::ledger_index] = jss::validated;
370 jvParams[jss::vault_id] = "0";
371 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
372 checkError(jv[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
373 }
374
375 {
376 testcase("RPC vault_info json by owner and sequence");
377 json::Value jvParams;
378 jvParams[jss::ledger_index] = jss::validated;
379 jvParams[jss::owner] = owner.human();
380 jvParams[jss::seq] = sequence;
381 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
382
383 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
384 BEAST_EXPECT(jv[jss::result].isMember(jss::vault));
385 check(jv[jss::result][jss::vault], jv[jss::result][jss::vault][jss::shares]);
386 }
387
388 {
389 testcase("RPC vault_info json malformed sequence");
390 json::Value jvParams;
391 jvParams[jss::ledger_index] = jss::validated;
392 jvParams[jss::owner] = owner.human();
393 jvParams[jss::seq] = "foobar";
394 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
395 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badSeqMessage);
396 }
397
398 {
399 testcase("RPC vault_info json invalid sequence");
400 json::Value jvParams;
401 jvParams[jss::ledger_index] = jss::validated;
402 jvParams[jss::owner] = owner.human();
403 jvParams[jss::seq] = 0;
404 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
405 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badSeqMessage);
406 }
407
408 {
409 testcase("RPC vault_info json negative sequence");
410 json::Value jvParams;
411 jvParams[jss::ledger_index] = jss::validated;
412 jvParams[jss::owner] = owner.human();
413 jvParams[jss::seq] = -1;
414 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
415 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badSeqMessage);
416 }
417
418 {
419 testcase("RPC vault_info json oversized sequence");
420 json::Value jvParams;
421 jvParams[jss::ledger_index] = jss::validated;
422 jvParams[jss::owner] = owner.human();
423 jvParams[jss::seq] = 1e20;
424 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
425 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badSeqMessage);
426 }
427
428 {
429 testcase("RPC vault_info json bool sequence");
430 json::Value jvParams;
431 jvParams[jss::ledger_index] = jss::validated;
432 jvParams[jss::owner] = owner.human();
433 jvParams[jss::seq] = true;
434 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
435 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badSeqMessage);
436 }
437
438 {
439 testcase("RPC vault_info json malformed owner");
440 json::Value jvParams;
441 jvParams[jss::ledger_index] = jss::validated;
442 jvParams[jss::owner] = "foobar";
443 jvParams[jss::seq] = sequence;
444 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
445 checkError(
446 jv[jss::result],
447 "actMalformed",
449 "Invalid field 'owner', not AccountID.");
450 }
451
452 {
453 testcase("RPC vault_info json array owner");
454 json::Value jvParams;
455 jvParams[jss::ledger_index] = jss::validated;
456 jvParams[jss::owner] = json::Value(json::ValueType::Array);
457 jvParams[jss::seq] = sequence;
458 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
459 checkError(
460 jv[jss::result],
461 "actMalformed",
463 "Invalid field 'owner', not AccountID.");
464 }
465
466 {
467 testcase("RPC vault_info json invalid combination only owner");
468 json::Value jvParams;
469 jvParams[jss::ledger_index] = jss::validated;
470 jvParams[jss::owner] = owner.human();
471 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
472 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badFieldsMessage);
473 }
474
475 {
476 testcase("RPC vault_info json invalid combination only seq");
477 json::Value jvParams;
478 jvParams[jss::ledger_index] = jss::validated;
479 jvParams[jss::seq] = sequence;
480 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
481 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badFieldsMessage);
482 }
483
484 {
485 testcase("RPC vault_info json invalid combination seq vault_id");
486 json::Value jvParams;
487 jvParams[jss::ledger_index] = jss::validated;
488 jvParams[jss::vault_id] = strHex(keylet.key);
489 jvParams[jss::seq] = sequence;
490 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
491 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badFieldsMessage);
492 }
493
494 {
495 testcase("RPC vault_info json invalid combination owner vault_id");
496 json::Value jvParams;
497 jvParams[jss::ledger_index] = jss::validated;
498 jvParams[jss::vault_id] = strHex(keylet.key);
499 jvParams[jss::owner] = owner.human();
500 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
501 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badFieldsMessage);
502 }
503
504 {
505 testcase(
506 "RPC vault_info json invalid combination owner seq "
507 "vault_id");
508 json::Value jvParams;
509 jvParams[jss::ledger_index] = jss::validated;
510 jvParams[jss::vault_id] = strHex(keylet.key);
511 jvParams[jss::seq] = sequence;
512 jvParams[jss::owner] = owner.human();
513 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
514 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badFieldsMessage);
515 }
516
517 {
518 testcase("RPC vault_info json no input");
519 json::Value jvParams;
520 jvParams[jss::ledger_index] = jss::validated;
521 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
522 checkError(jv[jss::result], "invalidParams", RpcInvalidParams, badFieldsMessage);
523 }
524
525 {
526 testcase("RPC vault_info command line invalid index");
527 json::Value const jv = env.rpc("vault_info", "foobar", "validated");
528 checkError(jv, "invalidParams", RpcInvalidParams, "Invalid parameters.");
529 }
530
531 {
532 testcase("RPC vault_info command line zero index");
533 json::Value jv = env.rpc("vault_info", "0", "validated");
534 checkError(jv[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
535 }
536
537 {
538 testcase("RPC vault_info command line unknown index");
539 json::Value jv = env.rpc("vault_info", strHex(UInt256(42)), "validated");
540 checkError(jv[jss::result], "entryNotFound", RpcEntryNotFound, "Entry not found.");
541 }
542
543 {
544 testcase("RPC vault_info command line invalid ledger");
545 json::Value jv = env.rpc("vault_info", strHex(keylet.key), "0");
546 checkError(jv[jss::result], "lgrNotFound", RpcLgrNotFound, "ledgerNotFound");
547 }
548 }
549
550 // RPC coverage: closed-ended vaults must return VaultKind, SubscriptionDate and RedemptionDate
551 // in both vault_info and ledger_entry responses. Open-ended vaults must not.
552 void
554 {
555 using namespace test::jtx;
556
557 testcase("RPC closed-ended vault fields");
558 Env env{*this, testableAmendments()};
559 Account const owner{"owner"};
560 Account const owner2{"owner2"};
561 env.fund(XRP(1000), owner, owner2);
562 env.close();
563
564 auto const closedEnded = std::to_underlying(VaultKind::ClosedEnded);
565 Asset const asset = xrpIssue();
566 auto const sub = env.now().time_since_epoch().count() + 60;
567 auto const red = sub + kMinInvestmentPeriod;
568
569 Vault const vault{env};
570 auto [tx, keylet] = vault.create({
571 .owner = owner,
572 .asset = asset,
573 .vaultKind = closedEnded,
574 .subscriptionDate = sub,
575 .redemptionDate = red,
576 });
577 env(tx);
578 env.close();
579
580 auto [tx2, keylet2] = vault.create({.owner = owner2, .asset = asset});
581 env(tx2);
582 env.close();
583
584 auto const asUInt = [](json::Value const& jv) -> json::UInt {
585 return jv.isUInt() ? jv.asUInt() : json::UInt(jv.asInt());
586 };
587 auto const checkClosedEnded = [&](json::Value const& v) {
588 BEAST_EXPECT(v.isObject());
589 BEAST_EXPECT(v.isMember(sfVaultKind.fieldName));
590 BEAST_EXPECT(asUInt(v[sfVaultKind.fieldName]) == json::UInt(closedEnded));
591 BEAST_EXPECT(v.isMember(sfSubscriptionDate.fieldName));
592 BEAST_EXPECT(asUInt(v[sfSubscriptionDate.fieldName]) == json::UInt(sub));
593 BEAST_EXPECT(v.isMember(sfRedemptionDate.fieldName));
594 BEAST_EXPECT(asUInt(v[sfRedemptionDate.fieldName]) == json::UInt(red));
595 };
596 auto const checkOpenEnded = [&](json::Value const& v) {
597 BEAST_EXPECT(v.isObject());
598 BEAST_EXPECT(!v.isMember(sfVaultKind.fieldName));
599 BEAST_EXPECT(!v.isMember(sfSubscriptionDate.fieldName));
600 BEAST_EXPECT(!v.isMember(sfRedemptionDate.fieldName));
601 };
602
603 {
604 json::Value jvParams;
605 jvParams[jss::vault_id] = strHex(keylet.key);
606 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
607 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
608 checkClosedEnded(jv[jss::result][jss::vault]);
609 }
610 {
611 json::Value jvParams;
612 jvParams[jss::ledger_index] = jss::validated;
613 jvParams[jss::vault] = strHex(keylet.key);
614 auto jv = env.rpc("json", "ledger_entry", to_string(jvParams));
615 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
616 checkClosedEnded(jv[jss::result][jss::node]);
617 }
618 {
619 json::Value jvParams;
620 jvParams[jss::vault_id] = strHex(keylet2.key);
621 auto jv = env.rpc("json", "vault_info", to_string(jvParams));
622 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
623 checkOpenEnded(jv[jss::result][jss::vault]);
624 }
625 {
626 json::Value jvParams;
627 jvParams[jss::ledger_index] = jss::validated;
628 jvParams[jss::vault] = strHex(keylet2.key);
629 auto jv = env.rpc("json", "ledger_entry", to_string(jvParams));
630 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
631 checkOpenEnded(jv[jss::result][jss::node]);
632 }
633 }
634
635public:
636 void
637 run() override
638 {
639 testRPC();
641 }
642};
643
645
646} // namespace xrpl
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
Identifies fields.
Definition SField.h:131
void run() override
Runs the suite.
Shared base for the Vault*_test family under src/test/app/vault/.
test::jtx::PrettyAsset PrettyAsset
constexpr Zero kZero
Definition Zero.h:30
int Int
unsigned int UInt
@ Array
array value (ordered list)
Definition json_value.h:32
@ Object
object value (collection of name/value pairs).
Definition json_value.h:33
@ Null
'null' value
Definition json_value.h:26
Keylet computation functions.
Definition Indexes.h:39
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition Issue.h:108
ErrorCodeI
Definition ErrorCodes.h:23
@ RpcLgrNotFound
Definition ErrorCodes.h:55
@ RpcEntryNotFound
Definition ErrorCodes.h:144
@ RpcActMalformed
Definition ErrorCodes.h:73
@ RpcInvalidParams
Definition ErrorCodes.h:67
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
std::string toBase58(AccountID const &v)
Convert AccountID to base58 checked string.
Definition AccountID.cpp:95
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
json::Value toJson(Asset const &asset)
Definition Asset.h:168
BaseUInt< 256 > UInt256
Definition base_uint.h:581
constexpr std::uint8_t kVaultStrategyFirstComeFirstServe
Vault withdrawal policies.
Definition Protocol.h:308
constexpr std::uint32_t kMinInvestmentPeriod
Bounds on the length of a closed-ended vault's Investment phase (RedemptionDate - SubscriptionDate).
Definition Protocol.h:391
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)