43 Env env{*
this, testableAmendments()};
46 Vault const vault{env};
47 env.fund(XRP(1000), issuer, owner);
51 env.trust(asset(1000), owner);
52 env(pay(issuer, owner, asset(200)));
55 auto const sequence = env.seq(owner);
56 auto [tx,
keylet] = vault.create({.owner = owner, .asset = asset});
63 vault.deposit({.depositor = owner, .id =
keylet.key, .amount = asset(50)});
66 auto tx2 = vault.set({.owner = owner, .id =
keylet.key});
67 tx2[sfAssetsMaximum] = asset(1000).number();
73 auto const vault = env.le(
keylet);
74 BEAST_EXPECT(vault !=
nullptr);
78 auto const check = [&,
keylet =
keylet, sle = sleVault,
this](
81 BEAST_EXPECT(vault.isObject());
83 static constexpr auto kCheckString =
85 return node.isMember(field.fieldName) && node[field.fieldName].isString() &&
86 node[field.fieldName] == v;
88 static constexpr auto kCheckObject =
90 return node.isMember(field.fieldName) && node[field.fieldName].isObject() &&
91 node[field.fieldName] == v;
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)));
99 BEAST_EXPECT(vault[
"LedgerEntryType"].asString() ==
"Vault");
100 BEAST_EXPECT(vault[jss::index].asString() ==
strHex(
keylet.key));
101 BEAST_EXPECT(kCheckInt(vault, sfFlags, 0));
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()));
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));
117 if (issuance.isObject())
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"));
130 auto const checkError = [
this](
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);
140 std::string const badSeqMessage =
"Invalid field 'seq', not a positive 32-bit integer.";
142 "Must specify either 'vault_id' or both 'owner' and 'seq'.";
145 testcase(
"RPC ledger_entry selected by key");
147 jvParams[jss::ledger_index] = jss::validated;
149 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
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]);
157 testcase(
"RPC ledger_entry selected by owner and seq");
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));
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]);
170 testcase(
"RPC ledger_entry cannot find vault by key");
172 jvParams[jss::ledger_index] = jss::validated;
174 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
175 checkError(jvVault[jss::result],
"entryNotFound",
RpcEntryNotFound,
"Entry not found.");
179 testcase(
"RPC ledger_entry cannot find vault by owner and seq");
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.");
189 testcase(
"RPC ledger_entry malformed key");
191 jvParams[jss::ledger_index] = jss::validated;
192 jvParams[jss::vault] = 42;
193 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
195 jvVault[jss::result],
198 "Invalid field 'vault', not hex string or object.");
202 testcase(
"RPC ledger_entry malformed owner");
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));
209 jvVault[jss::result],
212 "Invalid field 'owner', not AccountID.");
216 testcase(
"RPC ledger_entry malformed seq");
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));
223 jvVault[jss::result],
226 "Invalid field 'seq', not number.");
230 testcase(
"RPC ledger_entry negative seq");
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));
237 jvVault[jss::result],
240 "Invalid field 'seq', not number.");
244 testcase(
"RPC ledger_entry oversized seq");
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));
251 jvVault[jss::result],
254 "Invalid field 'seq', not number.");
258 testcase(
"RPC ledger_entry bool seq");
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));
265 jvVault[jss::result],
268 "Invalid field 'seq', not number.");
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];
279 BEAST_EXPECT(jv[jss::account_objects].size() == 1);
280 check(jv[jss::account_objects][0u]);
287 jvParams[jss::ledger_index] = jss::validated;
288 jvParams[jss::binary] =
false;
289 jvParams[jss::type] = jss::vault;
291 BEAST_EXPECT(jv[jss::result][jss::state].size() == 1);
292 check(jv[jss::result][jss::state][0u]);
296 testcase(
"RPC vault_info command line");
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]);
307 jvParams[jss::ledger_index] = jss::validated;
309 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
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]);
317 testcase(
"RPC vault_info invalid vault_id");
319 jvParams[jss::ledger_index] = jss::validated;
320 jvParams[jss::vault_id] =
"foobar";
321 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
326 "Invalid field 'vault_id', not hex string.");
330 testcase(
"RPC vault_info json numeric vault_id");
332 jvParams[jss::ledger_index] = jss::validated;
333 jvParams[jss::vault_id] = 0;
334 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
339 "Invalid field 'vault_id', not hex string.");
343 testcase(
"RPC vault_info json object vault_id");
345 jvParams[jss::ledger_index] = jss::validated;
347 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
352 "Invalid field 'vault_id', not hex string.");
358 testcase(
"RPC vault_info json all zero vault_id");
360 jvParams[jss::ledger_index] = jss::validated;
362 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
363 checkError(jv[jss::result],
"entryNotFound",
RpcEntryNotFound,
"Entry not found.");
367 testcase(
"RPC vault_info json short zero vault_id");
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.");
376 testcase(
"RPC vault_info json by owner and sequence");
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));
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]);
389 testcase(
"RPC vault_info json malformed sequence");
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);
399 testcase(
"RPC vault_info json invalid sequence");
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);
409 testcase(
"RPC vault_info json negative sequence");
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);
419 testcase(
"RPC vault_info json oversized sequence");
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);
429 testcase(
"RPC vault_info json bool sequence");
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);
439 testcase(
"RPC vault_info json malformed owner");
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));
449 "Invalid field 'owner', not AccountID.");
453 testcase(
"RPC vault_info json array owner");
455 jvParams[jss::ledger_index] = jss::validated;
457 jvParams[jss::seq] = sequence;
458 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
463 "Invalid field 'owner', not AccountID.");
467 testcase(
"RPC vault_info json invalid combination only owner");
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);
476 testcase(
"RPC vault_info json invalid combination only seq");
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);
485 testcase(
"RPC vault_info json invalid combination seq vault_id");
487 jvParams[jss::ledger_index] = jss::validated;
489 jvParams[jss::seq] = sequence;
490 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
491 checkError(jv[jss::result],
"invalidParams",
RpcInvalidParams, badFieldsMessage);
495 testcase(
"RPC vault_info json invalid combination owner vault_id");
497 jvParams[jss::ledger_index] = jss::validated;
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);
506 "RPC vault_info json invalid combination owner seq "
509 jvParams[jss::ledger_index] = jss::validated;
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);
518 testcase(
"RPC vault_info json no input");
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);
526 testcase(
"RPC vault_info command line invalid index");
527 json::Value const jv = env.rpc(
"vault_info",
"foobar",
"validated");
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.");
538 testcase(
"RPC vault_info command line unknown index");
540 checkError(jv[jss::result],
"entryNotFound",
RpcEntryNotFound,
"Entry not found.");
544 testcase(
"RPC vault_info command line invalid ledger");
546 checkError(jv[jss::result],
"lgrNotFound",
RpcLgrNotFound,
"ledgerNotFound");
557 testcase(
"RPC closed-ended vault fields");
558 Env env{*
this, testableAmendments()};
560 Account const owner2{
"owner2"};
561 env.fund(XRP(1000), owner, owner2);
566 auto const sub = env.now().time_since_epoch().count() + 60;
569 Vault const vault{env};
570 auto [tx,
keylet] = vault.create({
573 .vaultKind = closedEnded,
574 .subscriptionDate = sub,
575 .redemptionDate = red,
580 auto [tx2, keylet2] = vault.create({.owner = owner2, .asset = asset});
585 return jv.isUInt() ? jv.asUInt() :
json::UInt(jv.asInt());
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));
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));
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]);
612 jvParams[jss::ledger_index] = jss::validated;
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]);
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]);
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]);