+
+
+
3588 using namespace test::jtx;
+
+
+
+
3592 Account
const& owner;
+
3593 Account
const& issuer;
+
3594 Account
const& depositor;
+
3595 Account
const& vaultAccount;
+
+
+
+
+
+
+
+
+
+
3605 auto testCase = [&,
this](
+
+
+
3608 Env env{*
this, testable_amendments() | featureSingleAssetVault};
+
3609 Account
const owner{
"owner"};
+
3610 Account
const issuer{
"issuer"};
+
3611 Account
const depositor{
"depositor"};
+
+
3613 env.fund(XRP(1000), issuer, owner, depositor);
+
+
+
+
+
3618 env.trust(asset(1000), owner);
+
3619 env.trust(asset(1000), depositor);
+
3620 env(pay(issuer, owner, asset(200)));
+
3621 env(pay(issuer, depositor, asset(200)));
+
+
+
3624 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
+
3625 tx[sfScale] = scale;
+
+
+
3628 auto const [vaultAccount, issuanceId] =
+
+
3630 auto const vault = env.le(keylet);
+
+
3632 Account(
"vault", vault->at(sfAccount)),
+
3633 vault->at(sfShareMPTID)};
+
+
+
3636 env.memoize(vaultAccount);
+
+
+
+
3640 return env.app().openLedger().modify(
+
+
+
+
3644 if (!BEAST_EXPECT(vault !=
nullptr))
+
+
3646 auto shares = sb.
peek(
+
+
3648 if (!BEAST_EXPECT(shares !=
nullptr))
+
+
3650 if (fn(*vault, *shares))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
3665 .depositor = depositor,
+
3666 .vaultAccount = vaultAccount,
+
+
+
+
+
+
+
+
+
+
3676 testCase(18, [&,
this](Env& env, Data d) {
+
3677 testcase(
"Scale deposit overflow on first deposit");
+
3678 auto tx = d.vault.deposit(
+
3679 {.depositor = d.depositor,
+
+
3681 .amount = d.asset(10)});
+
+
+
+
+
3686 testCase(18, [&,
this](Env& env, Data d) {
+
3687 testcase(
"Scale deposit overflow on second deposit");
+
+
+
3690 auto tx = d.vault.deposit(
+
3691 {.depositor = d.depositor,
+
+
3693 .amount = d.asset(5)});
+
+
+
+
+
+
3699 auto tx = d.vault.deposit(
+
3700 {.depositor = d.depositor,
+
+
3702 .amount = d.asset(10)});
+
+
+
+
+
+
3708 testCase(18, [&,
this](Env& env, Data d) {
+
3709 testcase(
"Scale deposit overflow on total shares");
+
+
+
3712 auto tx = d.vault.deposit(
+
3713 {.depositor = d.depositor,
+
+
3715 .amount = d.asset(5)});
+
+
+
+
+
+
3721 auto tx = d.vault.deposit(
+
3722 {.depositor = d.depositor,
+
+
3724 .amount = d.asset(5)});
+
+
+
+
+
+
3730 testCase(1, [&,
this](Env& env, Data d) {
+
+
+
3733 auto const start = env.balance(d.depositor, d.assets).number();
+
3734 auto tx = d.vault.deposit(
+
3735 {.depositor = d.depositor,
+
+
3737 .amount = d.asset(1)});
+
+
+
3740 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(10));
+
+
3742 env.balance(d.depositor, d.assets) ==
+
+
+
+
3746 testCase(1, [&,
this](Env& env, Data d) {
+
3747 testcase(
"Scale deposit insignificant amount");
+
+
3749 auto tx = d.vault.deposit(
+
3750 {.depositor = d.depositor,
+
+
+
+
+
+
3756 testCase(1, [&,
this](Env& env, Data d) {
+
3757 testcase(
"Scale deposit exact, using full precision");
+
+
3759 auto const start = env.balance(d.depositor, d.assets).number();
+
3760 auto tx = d.vault.deposit(
+
3761 {.depositor = d.depositor,
+
+
+
+
+
3766 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(15));
+
+
3768 env.balance(d.depositor, d.assets) ==
+
+
+
+
3772 testCase(1, [&,
this](Env& env, Data d) {
+
3773 testcase(
"Scale deposit exact, truncating from .5");
+
+
3775 auto const start = env.balance(d.depositor, d.assets).number();
+
+
+
+
3779 auto tx = d.vault.deposit(
+
3780 {.depositor = d.depositor,
+
+
+
+
+
3785 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(12));
+
+
3787 env.balance(d.depositor, d.assets) ==
+
+
+
+
+
3792 auto tx = d.vault.deposit(
+
3793 {.depositor = d.depositor,
+
+
+
+
+
3798 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(24));
+
+
3800 env.balance(d.depositor, d.assets) ==
+
+
+
+
+
3805 auto tx = d.vault.deposit(
+
3806 {.depositor = d.depositor,
+
+
+
+
+
3811 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(36));
+
+
3813 env.balance(d.depositor, d.assets) ==
+
+
+
+
+
3818 testCase(1, [&,
this](Env& env, Data d) {
+
3819 testcase(
"Scale deposit exact, truncating from .01");
+
+
3821 auto const start = env.balance(d.depositor, d.assets).number();
+
+
3823 auto tx = d.vault.deposit(
+
3824 {.depositor = d.depositor,
+
+
+
+
+
3829 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(12));
+
+
3831 env.balance(d.depositor, d.assets) ==
+
+
+
+
+
3836 auto tx = d.vault.deposit(
+
3837 {.depositor = d.depositor,
+
+
+
+
+
3842 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(18));
+
+
3844 env.balance(d.depositor, d.assets) ==
+
+
+
+
+
3849 testCase(1, [&,
this](Env& env, Data d) {
+
3850 testcase(
"Scale deposit exact, truncating from .99");
+
+
3852 auto const start = env.balance(d.depositor, d.assets).number();
+
+
3854 auto tx = d.vault.deposit(
+
3855 {.depositor = d.depositor,
+
+
+
+
+
3860 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(12));
+
+
3862 env.balance(d.depositor, d.assets) ==
+
+
+
+
+
3867 auto tx = d.vault.deposit(
+
3868 {.depositor = d.depositor,
+
+
+
+
+
3873 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(18));
+
+
3875 env.balance(d.depositor, d.assets) ==
+
+
+
+
+
3880 testCase(1, [&,
this](Env& env, Data d) {
+
+
3882 auto const start = env.balance(d.depositor, d.assets).number();
+
3883 auto tx = d.vault.deposit(
+
3884 {.depositor = d.depositor,
+
+
+
+
+
3889 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(1000));
+
+
3891 env.balance(d.depositor, d.assets) ==
+
+
+
3894 env.balance(d.vaultAccount, d.assets) ==
+
+
+
3897 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
+
+
+
+
3906 auto const start = env.balance(d.depositor, d.assets).number();
+
3907 auto tx = d.vault.withdraw(
+
3908 {.depositor = d.depositor,
+
+
+
+
+
+
3914 env.balance(d.depositor, d.shares) == d.share(900));
+
+
3916 env.balance(d.depositor, d.assets) ==
+
+
+
3919 env.balance(d.vaultAccount, d.assets) ==
+
+
+
3922 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
3927 testcase(
"Scale redeem with rounding");
+
+
+
+
+
3932 auto const start = env.balance(d.depositor, d.assets).number();
+
3933 d.peek([](
SLE& vault,
auto&) ->
bool {
+
3934 vault[sfAssetsAvailable] =
Number(1);
+
+
+
+
+
+
+
+
3942 auto tx = d.vault.withdraw(
+
3943 {.depositor = d.depositor,
+
+
+
+
+
+
3949 env.balance(d.depositor, d.shares) == d.share(900 - 25));
+
+
3951 env.balance(d.depositor, d.assets) ==
+
+
+
3954 env.balance(d.vaultAccount, d.assets) ==
+
+
+
3957 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
+
+
+
+
+
3967 auto const start = env.balance(d.depositor, d.assets).number();
+
+
3969 tx = d.vault.withdraw(
+
3970 {.depositor = d.depositor,
+
+
+
+
+
+
3976 env.balance(d.depositor, d.shares) == d.share(875 - 21));
+
+
3978 env.balance(d.depositor, d.assets) ==
+
+
+
3981 env.balance(d.vaultAccount, d.assets) ==
+
+
+
3984 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
+
3990 auto const rest = env.balance(d.depositor, d.shares).number();
+
+
3992 tx = d.vault.withdraw(
+
3993 {.depositor = d.depositor,
+
+
3995 .amount =
STAmount(d.share, rest)});
+
+
+
3998 BEAST_EXPECT(env.balance(d.depositor, d.shares).number() == 0);
+
+
4000 env.balance(d.vaultAccount, d.assets).number() == 0);
+
+
4002 env.balance(d.vaultAccount, d.shares).number() == 0);
+
+
+
+
4006 testCase(18, [&,
this](Env& env, Data d) {
+
4007 testcase(
"Scale withdraw overflow");
+
+
+
4010 auto tx = d.vault.deposit(
+
4011 {.depositor = d.depositor,
+
+
4013 .amount = d.asset(5)});
+
+
+
+
+
+
4019 auto tx = d.vault.withdraw(
+
4020 {.depositor = d.depositor,
+
+
+
+
+
+
+
+
4028 testCase(1, [&,
this](Env& env, Data d) {
+
+
4030 auto const start = env.balance(d.depositor, d.assets).number();
+
4031 auto tx = d.vault.deposit(
+
4032 {.depositor = d.depositor,
+
+
+
+
+
4037 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(1000));
+
+
4039 env.balance(d.depositor, d.assets) ==
+
+
+
4042 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4045 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
+
+
+
+
+
+
+
4057 auto const start = env.balance(d.depositor, d.assets).number();
+
4058 auto tx = d.vault.withdraw(
+
4059 {.depositor = d.depositor,
+
+
+
+
+
+
4065 env.balance(d.depositor, d.shares) == d.share(900));
+
+
4067 env.balance(d.depositor, d.assets) ==
+
+
+
4070 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4073 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
4078 testcase(
"Scale withdraw insignificant amount");
+
4079 auto tx = d.vault.withdraw(
+
4080 {.depositor = d.depositor,
+
+
+
+
+
+
+
4087 testcase(
"Scale withdraw with rounding assets");
+
+
+
+
+
+
+
+
4095 auto const start = env.balance(d.depositor, d.assets).number();
+
4096 d.peek([](
SLE& vault,
auto&) ->
bool {
+
4097 vault[sfAssetsAvailable] =
Number(1);
+
+
+
+
+
+
+
+
4105 auto tx = d.vault.withdraw(
+
4106 {.depositor = d.depositor,
+
+
+
+
+
+
4112 env.balance(d.depositor, d.shares) == d.share(900 - 25));
+
+
4114 env.balance(d.depositor, d.assets) ==
+
+
+
4117 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4120 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
4125 testcase(
"Scale withdraw with rounding shares up");
+
+
+
+
+
+
+
+
4133 auto const start = env.balance(d.depositor, d.assets).number();
+
4134 auto tx = d.vault.withdraw(
+
4135 {.depositor = d.depositor,
+
+
+
+
+
+
4141 env.balance(d.depositor, d.shares) == d.share(875 - 38));
+
+
4143 env.balance(d.depositor, d.assets) ==
+
+
+
4146 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4149 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
4154 testcase(
"Scale withdraw with rounding shares down");
+
+
+
+
+
+
+
+
4162 auto const start = env.balance(d.depositor, d.assets).number();
+
4163 auto tx = d.vault.withdraw(
+
4164 {.depositor = d.depositor,
+
+
+
+
+
+
4170 env.balance(d.depositor, d.shares) == d.share(837 - 37));
+
+
4172 env.balance(d.depositor, d.assets) ==
+
+
+
4175 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4178 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
4183 testcase(
"Scale withdraw tiny amount");
+
+
4185 auto const start = env.balance(d.depositor, d.assets).number();
+
4186 auto tx = d.vault.withdraw(
+
4187 {.depositor = d.depositor,
+
+
+
+
+
+
4193 env.balance(d.depositor, d.shares) == d.share(800 - 1));
+
+
4195 env.balance(d.depositor, d.assets) ==
+
+
+
4198 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4201 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
+
+
4208 env.balance(d.vaultAccount, d.assets).number();
+
+
4210 tx = d.vault.withdraw(
+
4211 {.depositor = d.depositor,
+
+
4213 .amount =
STAmount(d.asset, rest)});
+
+
+
4216 BEAST_EXPECT(env.balance(d.depositor, d.shares).number() == 0);
+
+
4218 env.balance(d.vaultAccount, d.assets).number() == 0);
+
+
4220 env.balance(d.vaultAccount, d.shares).number() == 0);
+
+
+
+
4224 testCase(18, [&,
this](Env& env, Data d) {
+
4225 testcase(
"Scale clawback overflow");
+
+
+
4228 auto tx = d.vault.deposit(
+
4229 {.depositor = d.depositor,
+
+
4231 .amount = d.asset(5)});
+
+
+
+
+
+
4237 auto tx = d.vault.clawback(
+
4238 {.issuer = d.issuer,
+
+
4240 .holder = d.depositor,
+
+
+
+
+
+
+
4247 testCase(1, [&,
this](Env& env, Data d) {
+
+
4249 auto const start = env.balance(d.depositor, d.assets).number();
+
4250 auto tx = d.vault.deposit(
+
4251 {.depositor = d.depositor,
+
+
+
+
+
4256 BEAST_EXPECT(env.balance(d.depositor, d.shares) == d.share(1000));
+
+
4258 env.balance(d.depositor, d.assets) ==
+
+
+
4261 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4264 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
+
+
+
+
+
+
4275 auto const start = env.balance(d.depositor, d.assets).number();
+
4276 auto tx = d.vault.clawback(
+
4277 {.issuer = d.issuer,
+
+
4279 .holder = d.depositor,
+
+
+
+
+
4284 env.balance(d.depositor, d.shares) == d.share(900));
+
+
4286 env.balance(d.depositor, d.assets) ==
+
+
+
4289 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4292 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
4297 testcase(
"Scale clawback insignificant amount");
+
4298 auto tx = d.vault.clawback(
+
4299 {.issuer = d.issuer,
+
+
4301 .holder = d.depositor,
+
+
+
+
+
+
4307 testcase(
"Scale clawback with rounding assets");
+
+
+
+
+
+
+
+
4315 auto const start = env.balance(d.depositor, d.assets).number();
+
4316 auto tx = d.vault.clawback(
+
4317 {.issuer = d.issuer,
+
+
4319 .holder = d.depositor,
+
+
+
+
+
4324 env.balance(d.depositor, d.shares) == d.share(900 - 25));
+
+
4326 env.balance(d.depositor, d.assets) ==
+
+
+
4329 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4332 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
4337 testcase(
"Scale clawback with rounding shares up");
+
+
+
+
+
+
+
+
4345 auto const start = env.balance(d.depositor, d.assets).number();
+
4346 auto tx = d.vault.clawback(
+
4347 {.issuer = d.issuer,
+
+
4349 .holder = d.depositor,
+
+
+
+
+
4354 env.balance(d.depositor, d.shares) == d.share(875 - 38));
+
+
4356 env.balance(d.depositor, d.assets) ==
+
+
+
4359 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4362 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
4367 testcase(
"Scale clawback with rounding shares down");
+
+
+
+
+
+
+
+
4375 auto const start = env.balance(d.depositor, d.assets).number();
+
4376 auto tx = d.vault.clawback(
+
4377 {.issuer = d.issuer,
+
+
4379 .holder = d.depositor,
+
+
+
+
+
4384 env.balance(d.depositor, d.shares) == d.share(837 - 37));
+
+
4386 env.balance(d.depositor, d.assets) ==
+
+
+
4389 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4392 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
4397 testcase(
"Scale clawback tiny amount");
+
+
4399 auto const start = env.balance(d.depositor, d.assets).number();
+
4400 auto tx = d.vault.clawback(
+
4401 {.issuer = d.issuer,
+
+
4403 .holder = d.depositor,
+
+
+
+
+
4408 env.balance(d.depositor, d.shares) == d.share(800 - 1));
+
+
4410 env.balance(d.depositor, d.assets) ==
+
+
+
4413 env.balance(d.vaultAccount, d.assets) ==
+
+
+
4416 env.balance(d.vaultAccount, d.shares) ==
+
+
+
+
+
+
+
4423 env.balance(d.vaultAccount, d.assets).number();
+
4424 d.peek([](
SLE& vault,
auto&) ->
bool {
+
4425 vault[sfAssetsAvailable] =
Number(5);
+
+
+
+
+
+
+
+
4433 tx = d.vault.clawback(
+
4434 {.issuer = d.issuer,
+
+
4436 .holder = d.depositor,
+
4437 .amount =
STAmount(d.asset, rest)});
+
+
+
4440 BEAST_EXPECT(env.balance(d.depositor, d.shares).number() == 0);
+
+
4442 env.balance(d.vaultAccount, d.assets).number() == 0);
+
+
4444 env.balance(d.vaultAccount, d.shares).number() == 0);
+
+
+
+
+
+
+
4452 using namespace test::jtx;
+
+
+
4455 Env env{*
this, testable_amendments() | featureSingleAssetVault};
+
4456 Account
const owner{
"owner"};
+
4457 Account
const issuer{
"issuer"};
+
+
4459 env.fund(XRP(1000), issuer, owner);
+
+
+
+
4463 env.trust(asset(1000), owner);
+
4464 env(pay(issuer, owner, asset(200)));
+
+
+
4467 auto const sequence = env.seq(owner);
+
4468 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
+
+
-
4472 auto tx2 = vault.set({.owner = owner, .id = keylet.
key});
-
4473 tx2[sfAssetsMaximum] = asset(1000).number();
-
-
-
+
+
+
4474 auto tx1 = vault.deposit(
+
4475 {.depositor = owner, .id = keylet.
key, .amount = asset(50)});
+
-
4478 auto const sleVault = [&env, keylet = keylet,
this]() {
-
4479 auto const vault = env.le(keylet);
-
4480 BEAST_EXPECT(vault !=
nullptr);
-
-
+
4478 auto tx2 = vault.set({.owner = owner, .id = keylet.
key});
+
4479 tx2[sfAssetsMaximum] = asset(1000).number();
+
+
+
-
4484 auto const check = [&, keylet = keylet, sle = sleVault,
this](
-
-
-
4487 BEAST_EXPECT(vault.isObject());
-
-
4489 constexpr auto checkString =
-
-
4491 return node.isMember(field.fieldName) &&
-
4492 node[field.fieldName].isString() &&
-
4493 node[field.fieldName] == v;
-
-
4495 constexpr auto checkObject =
-
+
4484 auto const sleVault = [&env, keylet = keylet,
this]() {
+
4485 auto const vault = env.le(keylet);
+
4486 BEAST_EXPECT(vault !=
nullptr);
+
+
+
+
4490 auto const check = [&, keylet = keylet, sle = sleVault,
this](
+
+
+
4493 BEAST_EXPECT(vault.isObject());
+
+
4495 constexpr auto checkString =
+
4497 return node.isMember(field.fieldName) &&
-
4498 node[field.fieldName].isObject() &&
+
4498 node[field.fieldName].isString() &&
4499 node[field.fieldName] == v;
-
4501 constexpr auto checkInt =
-
4502 [](
auto& node,
SField const& field,
int v) ->
bool {
+
4501 constexpr auto checkObject =
+
4503 return node.isMember(field.fieldName) &&
-
4504 ((node[field.fieldName].isInt() &&
-
4505 node[field.fieldName] ==
Json::Int(v)) ||
-
4506 (node[field.fieldName].isUInt() &&
-
-
-
-
4510 BEAST_EXPECT(vault[
"LedgerEntryType"].asString() ==
"Vault");
-
4511 BEAST_EXPECT(vault[jss::index].asString() ==
strHex(keylet.
key));
-
4512 BEAST_EXPECT(checkInt(vault, sfFlags, 0));
-
-
-
-
4516 checkString(vault, sfAccount,
toBase58(sle->at(sfAccount))));
-
-
4518 checkObject(vault, sfAsset,
to_json(sle->at(sfAsset))));
-
4519 BEAST_EXPECT(checkString(vault, sfAssetsAvailable,
"50"));
-
4520 BEAST_EXPECT(checkString(vault, sfAssetsMaximum,
"1000"));
-
4521 BEAST_EXPECT(checkString(vault, sfAssetsTotal,
"50"));
-
4522 BEAST_EXPECT(checkString(vault, sfLossUnrealized,
"0"));
-
-
4524 auto const strShareID =
strHex(sle->at(sfShareMPTID));
-
4525 BEAST_EXPECT(checkString(vault, sfShareMPTID, strShareID));
-
4526 BEAST_EXPECT(checkString(vault, sfOwner,
toBase58(owner.id())));
-
4527 BEAST_EXPECT(checkInt(vault, sfSequence, sequence));
-
4528 BEAST_EXPECT(checkInt(
-
-
-
4531 if (issuance.isObject())
-
-
-
4534 issuance[
"LedgerEntryType"].asString() ==
-
-
-
4537 issuance[jss::mpt_issuance_id].asString() == strShareID);
-
4538 BEAST_EXPECT(checkInt(issuance, sfSequence, 1));
-
4539 BEAST_EXPECT(checkInt(
-
-
-
-
-
4544 checkString(issuance, sfOutstandingAmount,
"50000000"));
-
-
-
-
-
4549 testcase(
"RPC ledger_entry selected by key");
-
-
4551 jvParams[jss::ledger_index] = jss::validated;
-
4552 jvParams[jss::vault] =
strHex(keylet.
key);
-
4553 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4555 BEAST_EXPECT(!jvVault[jss::result].isMember(jss::error));
-
4556 BEAST_EXPECT(jvVault[jss::result].isMember(jss::node));
-
4557 check(jvVault[jss::result][jss::node]);
-
-
-
-
4561 testcase(
"RPC ledger_entry selected by owner and seq");
-
-
4563 jvParams[jss::ledger_index] = jss::validated;
-
4564 jvParams[jss::vault][jss::owner] = owner.human();
-
4565 jvParams[jss::vault][jss::seq] = sequence;
-
4566 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4568 BEAST_EXPECT(!jvVault[jss::result].isMember(jss::error));
-
4569 BEAST_EXPECT(jvVault[jss::result].isMember(jss::node));
-
4570 check(jvVault[jss::result][jss::node]);
-
-
-
-
4574 testcase(
"RPC ledger_entry cannot find vault by key");
-
-
4576 jvParams[jss::ledger_index] = jss::validated;
-
-
4578 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4580 jvVault[jss::result][jss::error].asString() ==
"entryNotFound");
-
-
-
-
4584 testcase(
"RPC ledger_entry cannot find vault by owner and seq");
-
-
4586 jvParams[jss::ledger_index] = jss::validated;
-
4587 jvParams[jss::vault][jss::owner] = issuer.human();
-
4588 jvParams[jss::vault][jss::seq] = 1'000'000;
-
4589 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4591 jvVault[jss::result][jss::error].asString() ==
"entryNotFound");
-
-
-
-
4595 testcase(
"RPC ledger_entry malformed key");
-
-
4597 jvParams[jss::ledger_index] = jss::validated;
-
4598 jvParams[jss::vault] = 42;
-
4599 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4601 jvVault[jss::result][jss::error].asString() ==
-
4602 "malformedRequest");
-
-
-
-
4606 testcase(
"RPC ledger_entry malformed owner");
-
-
4608 jvParams[jss::ledger_index] = jss::validated;
-
4609 jvParams[jss::vault][jss::owner] = 42;
-
4610 jvParams[jss::vault][jss::seq] = sequence;
-
4611 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4613 jvVault[jss::result][jss::error].asString() ==
-
-
-
-
-
4618 testcase(
"RPC ledger_entry malformed seq");
-
-
4620 jvParams[jss::ledger_index] = jss::validated;
-
4621 jvParams[jss::vault][jss::owner] = issuer.human();
-
4622 jvParams[jss::vault][jss::seq] =
"foo";
-
4623 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4625 jvVault[jss::result][jss::error].asString() ==
-
4626 "malformedRequest");
-
-
-
-
4630 testcase(
"RPC ledger_entry negative seq");
-
-
4632 jvParams[jss::ledger_index] = jss::validated;
-
4633 jvParams[jss::vault][jss::owner] = issuer.human();
-
4634 jvParams[jss::vault][jss::seq] = -1;
-
4635 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4637 jvVault[jss::result][jss::error].asString() ==
-
4638 "malformedRequest");
-
-
-
-
4642 testcase(
"RPC ledger_entry oversized seq");
-
-
4644 jvParams[jss::ledger_index] = jss::validated;
-
4645 jvParams[jss::vault][jss::owner] = issuer.human();
-
4646 jvParams[jss::vault][jss::seq] = 1e20;
-
4647 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4649 jvVault[jss::result][jss::error].asString() ==
-
4650 "malformedRequest");
-
-
-
-
4654 testcase(
"RPC ledger_entry bool seq");
-
-
4656 jvParams[jss::ledger_index] = jss::validated;
-
4657 jvParams[jss::vault][jss::owner] = issuer.human();
-
4658 jvParams[jss::vault][jss::seq] =
true;
-
4659 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
-
-
4661 jvVault[jss::result][jss::error].asString() ==
-
4662 "malformedRequest");
-
-
-
-
-
-
-
4669 jvParams[jss::account] = owner.human();
-
4670 jvParams[jss::type] = jss::vault;
-
-
4672 "json",
"account_objects",
to_string(jvParams))[jss::result];
+
4504 node[field.fieldName].isObject() &&
+
4505 node[field.fieldName] == v;
+
+
4507 constexpr auto checkInt =
+
4508 [](
auto& node,
SField const& field,
int v) ->
bool {
+
4509 return node.isMember(field.fieldName) &&
+
4510 ((node[field.fieldName].isInt() &&
+
4511 node[field.fieldName] ==
Json::Int(v)) ||
+
4512 (node[field.fieldName].isUInt() &&
+
+
+
+
4516 BEAST_EXPECT(vault[
"LedgerEntryType"].asString() ==
"Vault");
+
4517 BEAST_EXPECT(vault[jss::index].asString() ==
strHex(keylet.
key));
+
4518 BEAST_EXPECT(checkInt(vault, sfFlags, 0));
+
+
+
+
4522 checkString(vault, sfAccount,
toBase58(sle->at(sfAccount))));
+
+
4524 checkObject(vault, sfAsset,
to_json(sle->at(sfAsset))));
+
4525 BEAST_EXPECT(checkString(vault, sfAssetsAvailable,
"50"));
+
4526 BEAST_EXPECT(checkString(vault, sfAssetsMaximum,
"1000"));
+
4527 BEAST_EXPECT(checkString(vault, sfAssetsTotal,
"50"));
+
4528 BEAST_EXPECT(checkString(vault, sfLossUnrealized,
"0"));
+
+
4530 auto const strShareID =
strHex(sle->at(sfShareMPTID));
+
4531 BEAST_EXPECT(checkString(vault, sfShareMPTID, strShareID));
+
4532 BEAST_EXPECT(checkString(vault, sfOwner,
toBase58(owner.id())));
+
4533 BEAST_EXPECT(checkInt(vault, sfSequence, sequence));
+
4534 BEAST_EXPECT(checkInt(
+
+
+
4537 if (issuance.isObject())
+
+
+
4540 issuance[
"LedgerEntryType"].asString() ==
+
+
+
4543 issuance[jss::mpt_issuance_id].asString() == strShareID);
+
4544 BEAST_EXPECT(checkInt(issuance, sfSequence, 1));
+
4545 BEAST_EXPECT(checkInt(
+
+
+
+
+
4550 checkString(issuance, sfOutstandingAmount,
"50000000"));
+
+
+
+
+
4555 testcase(
"RPC ledger_entry selected by key");
+
+
4557 jvParams[jss::ledger_index] = jss::validated;
+
4558 jvParams[jss::vault] =
strHex(keylet.
key);
+
4559 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4561 BEAST_EXPECT(!jvVault[jss::result].isMember(jss::error));
+
4562 BEAST_EXPECT(jvVault[jss::result].isMember(jss::node));
+
4563 check(jvVault[jss::result][jss::node]);
+
+
+
+
4567 testcase(
"RPC ledger_entry selected by owner and seq");
+
+
4569 jvParams[jss::ledger_index] = jss::validated;
+
4570 jvParams[jss::vault][jss::owner] = owner.human();
+
4571 jvParams[jss::vault][jss::seq] = sequence;
+
4572 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4574 BEAST_EXPECT(!jvVault[jss::result].isMember(jss::error));
+
4575 BEAST_EXPECT(jvVault[jss::result].isMember(jss::node));
+
4576 check(jvVault[jss::result][jss::node]);
+
+
+
+
4580 testcase(
"RPC ledger_entry cannot find vault by key");
+
+
4582 jvParams[jss::ledger_index] = jss::validated;
+
+
4584 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4586 jvVault[jss::result][jss::error].asString() ==
"entryNotFound");
+
+
+
+
4590 testcase(
"RPC ledger_entry cannot find vault by owner and seq");
+
+
4592 jvParams[jss::ledger_index] = jss::validated;
+
4593 jvParams[jss::vault][jss::owner] = issuer.human();
+
4594 jvParams[jss::vault][jss::seq] = 1'000'000;
+
4595 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4597 jvVault[jss::result][jss::error].asString() ==
"entryNotFound");
+
+
+
+
4601 testcase(
"RPC ledger_entry malformed key");
+
+
4603 jvParams[jss::ledger_index] = jss::validated;
+
4604 jvParams[jss::vault] = 42;
+
4605 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4607 jvVault[jss::result][jss::error].asString() ==
+
4608 "malformedRequest");
+
+
+
+
4612 testcase(
"RPC ledger_entry malformed owner");
+
+
4614 jvParams[jss::ledger_index] = jss::validated;
+
4615 jvParams[jss::vault][jss::owner] = 42;
+
4616 jvParams[jss::vault][jss::seq] = sequence;
+
4617 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4619 jvVault[jss::result][jss::error].asString() ==
+
+
+
+
+
4624 testcase(
"RPC ledger_entry malformed seq");
+
+
4626 jvParams[jss::ledger_index] = jss::validated;
+
4627 jvParams[jss::vault][jss::owner] = issuer.human();
+
4628 jvParams[jss::vault][jss::seq] =
"foo";
+
4629 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4631 jvVault[jss::result][jss::error].asString() ==
+
4632 "malformedRequest");
+
+
+
+
4636 testcase(
"RPC ledger_entry negative seq");
+
+
4638 jvParams[jss::ledger_index] = jss::validated;
+
4639 jvParams[jss::vault][jss::owner] = issuer.human();
+
4640 jvParams[jss::vault][jss::seq] = -1;
+
4641 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4643 jvVault[jss::result][jss::error].asString() ==
+
4644 "malformedRequest");
+
+
+
+
4648 testcase(
"RPC ledger_entry oversized seq");
+
+
4650 jvParams[jss::ledger_index] = jss::validated;
+
4651 jvParams[jss::vault][jss::owner] = issuer.human();
+
4652 jvParams[jss::vault][jss::seq] = 1e20;
+
4653 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4655 jvVault[jss::result][jss::error].asString() ==
+
4656 "malformedRequest");
+
+
+
+
4660 testcase(
"RPC ledger_entry bool seq");
+
+
4662 jvParams[jss::ledger_index] = jss::validated;
+
4663 jvParams[jss::vault][jss::owner] = issuer.human();
+
4664 jvParams[jss::vault][jss::seq] =
true;
+
4665 auto jvVault = env.rpc(
"json",
"ledger_entry",
to_string(jvParams));
+
+
4667 jvVault[jss::result][jss::error].asString() ==
+
4668 "malformedRequest");
+
+
+
+
-
4674 BEAST_EXPECT(jv[jss::account_objects].size() == 1);
-
4675 check(jv[jss::account_objects][0u]);
-
-
-
-
-
-
-
4682 jvParams[jss::ledger_index] = jss::validated;
-
4683 jvParams[jss::binary] =
false;
-
4684 jvParams[jss::type] = jss::vault;
-
-
4686 env.rpc(
"json",
"ledger_data",
to_string(jvParams));
-
4687 BEAST_EXPECT(jv[jss::result][jss::state].size() == 1);
-
4688 check(jv[jss::result][jss::state][0u]);
-
-
-
-
4692 testcase(
"RPC vault_info command line");
-
-
4694 env.rpc(
"vault_info",
strHex(keylet.
key),
"validated");
-
-
4696 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
-
4697 BEAST_EXPECT(jv[jss::result].isMember(jss::vault));
-
-
4699 jv[jss::result][jss::vault],
-
4700 jv[jss::result][jss::vault][jss::shares]);
-
-
-
-
-
-
4706 jvParams[jss::ledger_index] = jss::validated;
-
4707 jvParams[jss::vault_id] =
strHex(keylet.
key);
-
4708 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4710 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
-
4711 BEAST_EXPECT(jv[jss::result].isMember(jss::vault));
-
-
4713 jv[jss::result][jss::vault],
-
4714 jv[jss::result][jss::vault][jss::shares]);
-
-
-
-
4718 testcase(
"RPC vault_info invalid vault_id");
-
-
4720 jvParams[jss::ledger_index] = jss::validated;
-
4721 jvParams[jss::vault_id] =
"foobar";
-
4722 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4724 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4728 testcase(
"RPC vault_info json invalid index");
-
-
4730 jvParams[jss::ledger_index] = jss::validated;
-
4731 jvParams[jss::vault_id] = 0;
-
4732 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4734 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4738 testcase(
"RPC vault_info json by owner and sequence");
-
-
4740 jvParams[jss::ledger_index] = jss::validated;
-
4741 jvParams[jss::owner] = owner.human();
-
4742 jvParams[jss::seq] = sequence;
-
4743 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4745 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
-
4746 BEAST_EXPECT(jv[jss::result].isMember(jss::vault));
-
-
4748 jv[jss::result][jss::vault],
-
4749 jv[jss::result][jss::vault][jss::shares]);
-
-
-
-
4753 testcase(
"RPC vault_info json malformed sequence");
-
-
4755 jvParams[jss::ledger_index] = jss::validated;
-
4756 jvParams[jss::owner] = owner.human();
-
4757 jvParams[jss::seq] =
"foobar";
-
4758 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4760 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4764 testcase(
"RPC vault_info json invalid sequence");
-
-
4766 jvParams[jss::ledger_index] = jss::validated;
-
4767 jvParams[jss::owner] = owner.human();
-
4768 jvParams[jss::seq] = 0;
-
4769 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4771 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4775 testcase(
"RPC vault_info json negative sequence");
-
-
4777 jvParams[jss::ledger_index] = jss::validated;
-
4778 jvParams[jss::owner] = owner.human();
-
4779 jvParams[jss::seq] = -1;
-
4780 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4782 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4786 testcase(
"RPC vault_info json oversized sequence");
-
-
4788 jvParams[jss::ledger_index] = jss::validated;
-
4789 jvParams[jss::owner] = owner.human();
-
4790 jvParams[jss::seq] = 1e20;
-
4791 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4793 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4797 testcase(
"RPC vault_info json bool sequence");
-
-
4799 jvParams[jss::ledger_index] = jss::validated;
-
4800 jvParams[jss::owner] = owner.human();
-
4801 jvParams[jss::seq] =
true;
-
4802 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4804 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4808 testcase(
"RPC vault_info json malformed owner");
-
-
4810 jvParams[jss::ledger_index] = jss::validated;
-
4811 jvParams[jss::owner] =
"foobar";
-
4812 jvParams[jss::seq] = sequence;
-
4813 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4815 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4819 testcase(
"RPC vault_info json invalid combination only owner");
-
-
4821 jvParams[jss::ledger_index] = jss::validated;
-
4822 jvParams[jss::owner] = owner.human();
-
4823 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4825 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4829 testcase(
"RPC vault_info json invalid combination only seq");
-
-
4831 jvParams[jss::ledger_index] = jss::validated;
-
4832 jvParams[jss::seq] = sequence;
-
4833 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4835 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4839 testcase(
"RPC vault_info json invalid combination seq vault_id");
-
-
4841 jvParams[jss::ledger_index] = jss::validated;
-
4842 jvParams[jss::vault_id] =
strHex(keylet.
key);
-
4843 jvParams[jss::seq] = sequence;
-
4844 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4846 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4850 testcase(
"RPC vault_info json invalid combination owner vault_id");
-
-
4852 jvParams[jss::ledger_index] = jss::validated;
-
4853 jvParams[jss::vault_id] =
strHex(keylet.
key);
-
4854 jvParams[jss::owner] = owner.human();
-
4855 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4857 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
-
4862 "RPC vault_info json invalid combination owner seq "
-
-
-
4865 jvParams[jss::ledger_index] = jss::validated;
-
4866 jvParams[jss::vault_id] =
strHex(keylet.
key);
-
4867 jvParams[jss::seq] = sequence;
-
4868 jvParams[jss::owner] = owner.human();
-
4869 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4871 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4875 testcase(
"RPC vault_info json no input");
-
-
4877 jvParams[jss::ledger_index] = jss::validated;
-
4878 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
-
-
4880 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4884 testcase(
"RPC vault_info command line invalid index");
-
4885 Json::Value jv = env.rpc(
"vault_info",
"foobar",
"validated");
-
4886 BEAST_EXPECT(jv[jss::error].asString() ==
"invalidParams");
+
+
4675 jvParams[jss::account] = owner.human();
+
4676 jvParams[jss::type] = jss::vault;
+
+
4678 "json",
"account_objects",
to_string(jvParams))[jss::result];
+
+
4680 BEAST_EXPECT(jv[jss::account_objects].size() == 1);
+
4681 check(jv[jss::account_objects][0u]);
+
+
+
+
+
+
+
4688 jvParams[jss::ledger_index] = jss::validated;
+
4689 jvParams[jss::binary] =
false;
+
4690 jvParams[jss::type] = jss::vault;
+
+
4692 env.rpc(
"json",
"ledger_data",
to_string(jvParams));
+
4693 BEAST_EXPECT(jv[jss::result][jss::state].size() == 1);
+
4694 check(jv[jss::result][jss::state][0u]);
+
+
+
+
4698 testcase(
"RPC vault_info command line");
+
+
4700 env.rpc(
"vault_info",
strHex(keylet.
key),
"validated");
+
+
4702 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
+
4703 BEAST_EXPECT(jv[jss::result].isMember(jss::vault));
+
+
4705 jv[jss::result][jss::vault],
+
4706 jv[jss::result][jss::vault][jss::shares]);
+
+
+
+
+
+
4712 jvParams[jss::ledger_index] = jss::validated;
+
4713 jvParams[jss::vault_id] =
strHex(keylet.
key);
+
4714 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4716 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
+
4717 BEAST_EXPECT(jv[jss::result].isMember(jss::vault));
+
+
4719 jv[jss::result][jss::vault],
+
4720 jv[jss::result][jss::vault][jss::shares]);
+
+
+
+
4724 testcase(
"RPC vault_info invalid vault_id");
+
+
4726 jvParams[jss::ledger_index] = jss::validated;
+
4727 jvParams[jss::vault_id] =
"foobar";
+
4728 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4730 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4734 testcase(
"RPC vault_info json invalid index");
+
+
4736 jvParams[jss::ledger_index] = jss::validated;
+
4737 jvParams[jss::vault_id] = 0;
+
4738 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4740 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4744 testcase(
"RPC vault_info json by owner and sequence");
+
+
4746 jvParams[jss::ledger_index] = jss::validated;
+
4747 jvParams[jss::owner] = owner.human();
+
4748 jvParams[jss::seq] = sequence;
+
4749 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4751 BEAST_EXPECT(!jv[jss::result].isMember(jss::error));
+
4752 BEAST_EXPECT(jv[jss::result].isMember(jss::vault));
+
+
4754 jv[jss::result][jss::vault],
+
4755 jv[jss::result][jss::vault][jss::shares]);
+
+
+
+
4759 testcase(
"RPC vault_info json malformed sequence");
+
+
4761 jvParams[jss::ledger_index] = jss::validated;
+
4762 jvParams[jss::owner] = owner.human();
+
4763 jvParams[jss::seq] =
"foobar";
+
4764 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4766 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4770 testcase(
"RPC vault_info json invalid sequence");
+
+
4772 jvParams[jss::ledger_index] = jss::validated;
+
4773 jvParams[jss::owner] = owner.human();
+
4774 jvParams[jss::seq] = 0;
+
4775 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4777 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4781 testcase(
"RPC vault_info json negative sequence");
+
+
4783 jvParams[jss::ledger_index] = jss::validated;
+
4784 jvParams[jss::owner] = owner.human();
+
4785 jvParams[jss::seq] = -1;
+
4786 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4788 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4792 testcase(
"RPC vault_info json oversized sequence");
+
+
4794 jvParams[jss::ledger_index] = jss::validated;
+
4795 jvParams[jss::owner] = owner.human();
+
4796 jvParams[jss::seq] = 1e20;
+
4797 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4799 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4803 testcase(
"RPC vault_info json bool sequence");
+
+
4805 jvParams[jss::ledger_index] = jss::validated;
+
4806 jvParams[jss::owner] = owner.human();
+
4807 jvParams[jss::seq] =
true;
+
4808 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4810 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4814 testcase(
"RPC vault_info json malformed owner");
+
+
4816 jvParams[jss::ledger_index] = jss::validated;
+
4817 jvParams[jss::owner] =
"foobar";
+
4818 jvParams[jss::seq] = sequence;
+
4819 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4821 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4825 testcase(
"RPC vault_info json invalid combination only owner");
+
+
4827 jvParams[jss::ledger_index] = jss::validated;
+
4828 jvParams[jss::owner] = owner.human();
+
4829 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4831 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4835 testcase(
"RPC vault_info json invalid combination only seq");
+
+
4837 jvParams[jss::ledger_index] = jss::validated;
+
4838 jvParams[jss::seq] = sequence;
+
4839 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4841 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4845 testcase(
"RPC vault_info json invalid combination seq vault_id");
+
+
4847 jvParams[jss::ledger_index] = jss::validated;
+
4848 jvParams[jss::vault_id] =
strHex(keylet.
key);
+
4849 jvParams[jss::seq] = sequence;
+
4850 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4852 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4856 testcase(
"RPC vault_info json invalid combination owner vault_id");
+
+
4858 jvParams[jss::ledger_index] = jss::validated;
+
4859 jvParams[jss::vault_id] =
strHex(keylet.
key);
+
4860 jvParams[jss::owner] = owner.human();
+
4861 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4863 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
+
4868 "RPC vault_info json invalid combination owner seq "
+
+
+
4871 jvParams[jss::ledger_index] = jss::validated;
+
4872 jvParams[jss::vault_id] =
strHex(keylet.
key);
+
4873 jvParams[jss::seq] = sequence;
+
4874 jvParams[jss::owner] = owner.human();
+
4875 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4877 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4881 testcase(
"RPC vault_info json no input");
+
+
4883 jvParams[jss::ledger_index] = jss::validated;
+
4884 auto jv = env.rpc(
"json",
"vault_info",
to_string(jvParams));
+
+
4886 jv[jss::result][jss::error].asString() ==
"malformedRequest");
4890 testcase(
"RPC vault_info command line invalid index");
-
4891 Json::Value jv = env.rpc(
"vault_info",
"0",
"validated");
-
-
4893 jv[jss::result][jss::error].asString() ==
"malformedRequest");
-
-
-
-
4897 testcase(
"RPC vault_info command line invalid index");
-
-
-
-
4901 jv[jss::result][jss::error].asString() ==
"entryNotFound");
-
-
-
-
4905 testcase(
"RPC vault_info command line invalid ledger");
-
-
-
4908 jv[jss::result][jss::error].asString() ==
"lgrNotFound");
-
-
+
4891 Json::Value jv = env.rpc(
"vault_info",
"foobar",
"validated");
+
4892 BEAST_EXPECT(jv[jss::error].asString() ==
"invalidParams");
+
+
+
+
4896 testcase(
"RPC vault_info command line invalid index");
+
4897 Json::Value jv = env.rpc(
"vault_info",
"0",
"validated");
+
+
4899 jv[jss::result][jss::error].asString() ==
"malformedRequest");
+
+
+
+
4903 testcase(
"RPC vault_info command line invalid index");
+
+
+
+
4907 jv[jss::result][jss::error].asString() ==
"entryNotFound");
+
+
+
+
4911 testcase(
"RPC vault_info command line invalid ledger");
+
+
+
4914 jv[jss::result][jss::error].asString() ==
"lgrNotFound");
+
+
diff --git a/classripple_1_1VaultCreate-members.html b/classripple_1_1VaultCreate-members.html
index 7ebe4ba9ed..4ea437ac27 100644
--- a/classripple_1_1VaultCreate-members.html
+++ b/classripple_1_1VaultCreate-members.html
@@ -82,7 +82,7 @@ $(function() {
diff --git a/classripple_1_1VaultCreate.html b/classripple_1_1VaultCreate.html
index 5dfd65e344..785d96904b 100644
--- a/classripple_1_1VaultCreate.html
+++ b/classripple_1_1VaultCreate.html
@@ -255,8 +255,6 @@ Static Public Member Functions