94 Env env{*
this, features};
95 auto const alice =
Account(
"alice");
96 auto const bob =
Account(
"bob");
97 auto const usda = alice[
"USD"];
98 env.
fund(
XRP(10000), alice, bob);
99 auto const pk = alice.pk();
100 auto const settleDelay = 100s;
101 auto const chan =
channel(alice, bob, env.
seq(alice));
102 env(
create(alice, bob,
XRP(1000), settleDelay, pk));
107 auto const preAlice = env.
balance(alice);
108 env(
fund(alice, chan,
XRP(1000)));
109 auto const feeDrops = env.
current()->fees().base;
110 BEAST_EXPECT(env.
balance(alice) == preAlice -
XRP(1000) - feeDrops);
115 BEAST_EXPECT(chanBal ==
XRP(0));
116 BEAST_EXPECT(chanAmt ==
XRP(2000));
139 auto const iou = usda(100).value();
140 auto const negXRP =
XRP(-100).value();
141 auto const posXRP =
XRP(100).value();
151 auto const delta =
XRP(500);
152 auto const reqBal = chanBal + delta;
153 auto const authAmt = reqBal +
XRP(-100);
154 assert(reqBal <= chanAmt);
159 auto const preBob = env.
balance(bob);
160 auto const delta =
XRP(500);
161 auto const reqBal = chanBal + delta;
162 auto const authAmt = reqBal +
XRP(100);
163 assert(reqBal <= chanAmt);
164 env(
claim(alice, chan, reqBal, authAmt));
167 BEAST_EXPECT(env.
balance(bob) == preBob + delta);
172 auto preBob = env.
balance(bob);
173 auto const delta =
XRP(500);
174 auto const reqBal = chanBal + delta;
175 auto const authAmt = reqBal +
XRP(100);
176 assert(reqBal <= chanAmt);
177 auto const sig =
signClaimAuth(alice.pk(), alice.sk(), chan, authAmt);
178 env(
claim(bob, chan, reqBal, authAmt,
Slice(sig), alice.pk()));
181 auto const feeDrops = env.
current()->fees().base;
182 BEAST_EXPECT(env.
balance(bob) == preBob + delta - feeDrops);
187 env(
claim(bob, chan, reqBal, authAmt,
Slice(sig), alice.pk()),
191 BEAST_EXPECT(env.
balance(bob) == preBob - feeDrops);
195 auto const preBob = env.
balance(bob);
198 assert(reqAmt <= chanAmt);
199 auto const sig =
signClaimAuth(alice.pk(), alice.sk(), chan, authAmt);
203 BEAST_EXPECT(env.
balance(bob) == preBob);
214 env(
claim(bob, chan,
XRP(1500).value(),
XRP(1500).value(),
Slice(sig), bob.pk()),
222 env(
claim(bob, chan,
XRP(1500).value(),
XRP(1500).value(),
Slice(sig), alice.pk()),
229 auto const preAlice = env.
balance(alice);
230 auto const preBob = env.
balance(bob);
233 auto const feeDrops = env.
current()->fees().base;
234 auto const delta = chanAmt - chanBal;
236 BEAST_EXPECT(env.
balance(alice) == preAlice + delta);
237 BEAST_EXPECT(env.
balance(bob) == preBob - feeDrops);
314 auto const alice =
Account(
"alice");
315 auto const bob =
Account(
"bob");
316 auto const carol =
Account(
"carol");
319 Env env{*
this, features};
320 env.
fund(
XRP(10000), alice, bob);
321 auto const pk = alice.pk();
322 auto const settleDelay = 100s;
324 env.
current()->header().parentCloseTime + 3600s;
325 auto const channelFunds =
XRP(1000);
326 auto const chan =
channel(alice, bob, env.
seq(alice));
327 env(
create(alice, bob, channelFunds, settleDelay, pk, cancelAfter));
329 env.
close(cancelAfter);
334 auto const preAlice = env.
balance(alice);
335 auto const preBob = env.
balance(bob);
336 auto const delta =
XRP(500);
337 auto const reqBal = chanBal + delta;
338 auto const authAmt = reqBal +
XRP(100);
339 assert(reqBal <= chanAmt);
340 auto const sig =
signClaimAuth(alice.pk(), alice.sk(), chan, authAmt);
341 env(
claim(bob, chan, reqBal, authAmt,
Slice(sig), alice.pk()));
342 auto const feeDrops = env.
current()->fees().base;
344 BEAST_EXPECT(env.
balance(bob) == preBob - feeDrops);
345 BEAST_EXPECT(env.
balance(alice) == preAlice + channelFunds);
350 Env env{*
this, features};
351 env.
fund(
XRP(10000), alice, bob, carol);
352 auto const pk = alice.pk();
353 auto const settleDelay = 100s;
355 env.
current()->header().parentCloseTime + 3600s;
356 auto const channelFunds =
XRP(1000);
357 auto const chan =
channel(alice, bob, env.
seq(alice));
358 env(
create(alice, bob, channelFunds, settleDelay, pk, cancelAfter));
363 env.
close(cancelAfter);
365 auto const preAlice = env.
balance(alice);
368 BEAST_EXPECT(env.
balance(alice) == preAlice + channelFunds);
373 for (
bool const withFixPayChan : {
true,
false})
375 auto const amend = withFixPayChan ? features : features - fixPayChanCancelAfter;
376 Env env{*
this, amend};
377 env.
fund(
XRP(10000), alice, bob);
380 auto const pk = alice.pk();
381 auto const settleDelay = 100s;
382 auto const channelFunds =
XRP(1000);
384 env.
current()->header().parentCloseTime - 1s;
386 env(
create(alice, bob, channelFunds, settleDelay, pk, cancelAfter), txResult);
392 for (
bool const withFixPayChan : {
true,
false})
394 auto const amend = withFixPayChan ? features : features - fixPayChanCancelAfter;
395 Env env{*
this, amend};
396 env.
fund(
XRP(10000), alice, bob);
399 auto const pk = alice.pk();
400 auto const settleDelay = 100s;
401 auto const channelFunds =
XRP(1000);
403 env(
create(alice, bob, channelFunds, settleDelay, pk, cancelAfter),
681 auto const alice =
Account(
"alice");
682 auto const bob =
Account(
"bob");
683 auto const carol =
Account(
"carol");
684 auto const usda = alice[
"USD"];
686 Env env{*
this, features};
687 env.
fund(
XRP(10000), alice, bob, carol);
689 env(
fset(bob, asfDepositAuth));
692 auto const pk = alice.pk();
693 auto const settleDelay = 100s;
694 auto const chan =
channel(alice, bob, env.
seq(alice));
695 env(
create(alice, bob,
XRP(1000), settleDelay, pk));
703 env(
fund(alice, chan,
XRP(1000)));
711 auto const baseFee = env.
current()->fees().base;
712 auto const preBob = env.
balance(bob);
714 auto const delta =
XRP(500).value();
721 BEAST_EXPECT(env.
balance(bob) == preBob);
731 env(
claim(bob, chan, delta, delta,
Slice(sig), pk));
733 BEAST_EXPECT(env.
balance(bob) == preBob + delta - baseFee);
737 auto const delta =
XRP(600).value();
762 env(
claim(alice, chan, delta, delta,
Slice(sig), pk));
765 BEAST_EXPECT(env.
balance(bob) == preBob + delta - (3 * baseFee));
770 auto const delta =
XRP(800).value();
780 env(
fclear(bob, asfDepositAuth));
784 env(
claim(alice, chan, delta, delta));
786 BEAST_EXPECT(env.
balance(bob) == preBob +
XRP(800) - (5 * baseFee));
794 testcase(
"Deposit Authorization with Credentials");
798 char const credType[] =
"abcde";
803 Account const dillon(
"dillon");
808 env.
fund(
XRP(10000), alice, bob, carol, dillon, zelda);
810 auto const pk = alice.
pk();
811 auto const settleDelay = 100s;
812 auto const chan =
channel(alice, bob, env.
seq(alice));
813 env(
create(alice, bob,
XRP(1000), settleDelay, pk));
817 env(
fund(alice, chan,
XRP(1000)));
821 "D007AE4B6E1274B4AF872588267B810C2F82716726351D1C7D38D3E5499FC6"
824 auto const delta =
XRP(500).value();
829 env.
current()->header().parentCloseTime.time_since_epoch().count() + 100;
830 jv[sfExpiration.jsonName] = t;
836 std::string const credIdx = jv[jss::result][jss::index].asString();
839 env(
fset(bob, asfDepositAuth));
843 env(
claim(alice, chan, delta, delta),
852 env(
claim(alice, chan, delta, delta),
862 env(
claim(dillon, chan, delta, delta),
870 env(
claim(alice, chan, delta, delta),
881 for (
int i = 0; i < 10; ++i)
895 std::string const credIdx = jv[jss::result][jss::index].asString();
904 env.
fund(
XRP(10000), alice, bob, carol, dillon, zelda);
906 auto const pk = alice.
pk();
907 auto const settleDelay = 100s;
908 auto const chan =
channel(alice, bob, env.
seq(alice));
909 env(
create(alice, bob,
XRP(1000), settleDelay, pk));
913 env(
fund(alice, chan,
XRP(1000)));
916 auto const delta =
XRP(500).value();
926 std::string const credIdx = jv[jss::result][jss::index].asString();
936 env.
fund(
XRP(5000),
"alice",
"bob");
939 auto const pk = alice.
pk();
940 auto const settleDelay = 100s;
941 auto const chan =
channel(alice, bob, env.
seq(alice));
942 env(
create(alice, bob,
XRP(1000), settleDelay, pk));
945 env(
fund(alice, chan,
XRP(1000)));
948 "48004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
952 env(
fset(bob, asfDepositAuth));
957 env(
claim(alice, chan,
XRP(500).value(),
XRP(500).value()),
993 Env env{*
this, features};
994 auto const alice =
Account(
"alice");
995 auto const bob =
Account(
"bob");
997 env.
fund(
XRP(10000), alice, bob, charlie);
998 auto const pk = alice.pk();
999 auto const settleDelay = 3600s;
1000 auto const channelFunds =
XRP(1000);
1002 env(
create(alice, bob, channelFunds, settleDelay, pk));
1006 auto const testInvalidAccountParam = [&](
auto const& param) {
1008 params[jss::account] = param;
1010 env.
rpc(
"json",
"account_channels",
to_string(params))[jss::result];
1011 BEAST_EXPECT(jrr[jss::error] ==
"invalidParams");
1013 BEAST_EXPECT(jrr[jss::error_message] ==
"Invalid field 'account'.");
1016 testInvalidAccountParam(1);
1017 testInvalidAccountParam(1.1);
1018 testInvalidAccountParam(
true);
1025 auto const testInvalidDestAccountParam = [&](
auto const& param) {
1027 params[jss::account] = alice.human();
1028 params[jss::destination_account] = param;
1030 env.
rpc(
"json",
"account_channels",
to_string(params))[jss::result];
1031 BEAST_EXPECT(jrr[jss::error] ==
"invalidParams");
1033 BEAST_EXPECT(jrr[jss::error_message] ==
"Invalid field 'destination_account'.");
1036 testInvalidDestAccountParam(1);
1037 testInvalidDestAccountParam(1.1);
1038 testInvalidDestAccountParam(
true);
1046 params[jss::account] = alice.human();
1047 params[jss::destination_account] =
"";
1048 auto const jrr = env.
rpc(
"json",
"account_channels",
to_string(params))[jss::result];
1049 BEAST_EXPECT(jrr[jss::channels].
size() == 1);
1050 BEAST_EXPECT(jrr[jss::channels][0u][jss::channel_id] == chan1Str);
1051 BEAST_EXPECT(jrr[jss::channels][0u][jss::destination_account] == bob.human());
1056 params[jss::account] =
"llIIOO";
1057 auto const jrr = env.
rpc(
"json",
"account_channels",
to_string(params))[jss::result];
1058 BEAST_EXPECT(jrr[jss::error] ==
"actMalformed");
1060 BEAST_EXPECT(jrr[jss::error_message] ==
"Account malformed.");
1061 BEAST_EXPECT(!jrr.isMember(jss::ledger_index));
1062 BEAST_EXPECT(!jrr.isMember(jss::ledger_current_index));
1067 params[jss::account] =
Account(
"bogie").human();
1068 params[jss::limit] = 0;
1069 auto const jrr = env.
rpc(
"json",
"account_channels",
to_string(params))[jss::result];
1070 BEAST_EXPECT(jrr[jss::error] ==
"invalidParams");
1072 BEAST_EXPECT(jrr[jss::error_message] ==
"Invalid field 'limit'.");
1077 params[jss::account] = alice.human();
1078 params[jss::marker] = 1;
1079 auto const notString =
1080 env.
rpc(
"json",
"account_channels",
to_string(params))[jss::result];
1081 BEAST_EXPECT(notString[jss::error] ==
"invalidParams");
1083 BEAST_EXPECT(notString[jss::error_message] ==
"Invalid field 'marker', not string.");
1085 params[jss::marker] =
"NOT_A_MARKER";
1086 auto const malformed =
1087 env.
rpc(
"json",
"account_channels",
to_string(params))[jss::result];
1088 BEAST_EXPECT(malformed[jss::error] ==
"invalidParams");
1090 BEAST_EXPECT(malformed[jss::error_message] ==
"Invalid parameters.");
1093 auto const r = env.
rpc(
"account_channels", alice.human(), bob.human());
1094 BEAST_EXPECT(r[jss::result][jss::channels].
size() == 1);
1095 BEAST_EXPECT(r[jss::result][jss::channels][0u][jss::channel_id] == chan1Str);
1096 BEAST_EXPECT(r[jss::result][jss::validated]);
1099 auto const r = env.
rpc(
"account_channels", alice.human());
1100 BEAST_EXPECT(r[jss::result][jss::channels].
size() == 1);
1101 BEAST_EXPECT(r[jss::result][jss::channels][0u][jss::channel_id] == chan1Str);
1102 BEAST_EXPECT(r[jss::result][jss::validated]);
1105 auto const r = env.
rpc(
"account_channels", bob.human(), alice.human());
1106 BEAST_EXPECT(r[jss::result][jss::channels].
size() == 0);
1107 BEAST_EXPECT(r[jss::result][jss::validated]);
1110 env(
create(alice, bob, channelFunds, settleDelay, pk));
1113 auto const r = env.
rpc(
"account_channels", alice.human(), bob.human());
1114 BEAST_EXPECT(r[jss::result][jss::channels].
size() == 2);
1115 BEAST_EXPECT(r[jss::result][jss::validated]);
1116 BEAST_EXPECT(chan1Str != chan2Str);
1117 for (
auto const& c : {chan1Str, chan2Str})
1120 r[jss::result][jss::channels][0u][jss::channel_id] == c ||
1121 r[jss::result][jss::channels][1u][jss::channel_id] == c);
1129 testcase(
"Account channels RPC markers");
1134 auto const alice =
Account(
"alice");
1139 for (
int i = 0; i < n; ++i)
1146 Env env{*
this, features};
1148 for (
auto const& a : bobs)
1156 auto const settleDelay = 3600s;
1157 auto const channelFunds =
XRP(1);
1158 for (
auto const& b : bobs)
1160 env(
create(alice, b, channelFunds, settleDelay, alice.pk()));
1170 jvc[jss::account] = src.human();
1172 jvc[jss::destination_account] = dst->human();
1174 jvc[jss::limit] = *limit;
1176 jvc[jss::marker] = marker;
1178 return env.
rpc(
"json",
"account_channels",
to_string(jvc))[jss::result];
1183 auto const r = testLimit(env, alice);
1184 BEAST_EXPECT(r.isMember(jss::channels));
1185 BEAST_EXPECT(r[jss::channels].
size() == bobs.size());
1190 for (
auto const& a : bobs)
1195 for (
int limit = 1; limit < bobs.size() + 1; ++limit)
1197 auto leftToFind = bobsB58;
1198 auto const numFull = bobs.size() / limit;
1199 auto const numNonFull = ((bobs.size() % limit) != 0u) ? 1 : 0;
1203 auto const testIt = [&](
bool expectMarker,
int expectedBatchSize) {
1204 auto const r = testLimit(env, alice, limit, marker);
1205 BEAST_EXPECT(!expectMarker || r.isMember(jss::marker));
1206 if (r.isMember(jss::marker))
1207 marker = r[jss::marker];
1208 BEAST_EXPECT(r[jss::channels].
size() == expectedBatchSize);
1209 auto const c = r[jss::channels];
1210 auto const s = r[jss::channels].size();
1211 for (
int j = 0; j < s; ++j)
1213 auto const dstAcc = c[j][jss::destination_account].asString();
1214 BEAST_EXPECT(leftToFind.count(dstAcc));
1215 leftToFind.erase(dstAcc);
1219 for (
int i = 0; i < numFull; ++i)
1221 bool const expectMarker = (numNonFull != 0 || i < numFull - 1);
1222 testIt(expectMarker, limit);
1225 if (numNonFull != 0)
1227 testIt(
false, bobs.size() % limit);
1229 BEAST_EXPECT(leftToFind.empty());
1234 auto const r = testLimit(env, alice, 0);
1235 BEAST_EXPECT(r[jss::error] ==
"invalidParams");
1237 BEAST_EXPECT(r[jss::error_message] ==
"Invalid field 'limit'.");
1243 auto const first = testLimit(env, alice, 1);
1244 auto const marker = first[jss::marker].asString();
1245 auto const comma = marker.find(
',');
1246 BEAST_EXPECT(comma != std::string::npos);
1248 auto const rest = testLimit(
1252 marker.substr(0, comma) +
",+" + marker.substr(comma + 1) +
",ignored");
1253 BEAST_EXPECT(rest[jss::channels].
size() == bobs.size() - 1);
1256 first[jss::channels][0u][jss::destination_account].asString(),
1259 for (
auto const& c : rest[jss::channels])
1260 BEAST_EXPECT(found.
insert(c[jss::destination_account].asString()).second);
1262 BEAST_EXPECT(found == bobsB58);
1343 testcase(
"PayChan Auth/Verify RPC");
1344 using namespace jtx;
1346 Env env{*
this, features};
1347 auto const alice =
Account(
"alice");
1348 auto const bob =
Account(
"bob");
1350 env.
fund(
XRP(10000), alice, bob, charlie);
1351 auto const pk = alice.pk();
1352 auto const settleDelay = 3600s;
1353 auto const channelFunds =
XRP(1000);
1355 env(
create(alice, bob, channelFunds, settleDelay, pk));
1359 auto const r = env.
rpc(
"account_channels", alice.human(), bob.human());
1360 BEAST_EXPECT(r[jss::result][jss::channels].
size() == 1);
1361 BEAST_EXPECT(r[jss::result][jss::channels][0u][jss::channel_id] == chan1Str);
1362 BEAST_EXPECT(r[jss::result][jss::validated]);
1363 chan1PkStr = r[jss::result][jss::channels][0u][jss::public_key].asString();
1366 auto const r = env.
rpc(
"account_channels", alice.human());
1367 BEAST_EXPECT(r[jss::result][jss::channels].
size() == 1);
1368 BEAST_EXPECT(r[jss::result][jss::channels][0u][jss::channel_id] == chan1Str);
1369 BEAST_EXPECT(r[jss::result][jss::validated]);
1370 chan1PkStr = r[jss::result][jss::channels][0u][jss::public_key].asString();
1373 auto const r = env.
rpc(
"account_channels", bob.human(), alice.human());
1374 BEAST_EXPECT(r[jss::result][jss::channels].
size() == 0);
1375 BEAST_EXPECT(r[jss::result][jss::validated]);
1378 env(
create(alice, bob, channelFunds, settleDelay, pk));
1381 auto const r = env.
rpc(
"account_channels", alice.human(), bob.human());
1382 BEAST_EXPECT(r[jss::result][jss::channels].
size() == 2);
1383 BEAST_EXPECT(r[jss::result][jss::validated]);
1384 BEAST_EXPECT(chan1Str != chan2Str);
1385 for (
auto const& c : {chan1Str, chan2Str})
1388 r[jss::result][jss::channels][0u][jss::channel_id] == c ||
1389 r[jss::result][jss::channels][1u][jss::channel_id] == c);
1398 s +=
"0123456789ABCDEF"[((
byte & 0xf0) >> 4)];
1399 s +=
"0123456789ABCDEF"[((
byte & 0x0f) >> 0)];
1406 auto const rs = env.
rpc(
"channel_authorize",
"alice", chan1Str,
"1000");
1407 auto const sig = rs[jss::result][jss::signature].
asString();
1408 BEAST_EXPECT(!sig.empty());
1410 auto const rv = env.
rpc(
"channel_verify", chan1PkStr, chan1Str,
"1000", sig);
1411 BEAST_EXPECT(rv[jss::result][jss::signature_verified].asBool());
1417 auto const rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
"1000", sig);
1418 BEAST_EXPECT(rv[jss::result][jss::signature_verified].asBool());
1423 auto rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
"1000x", sig);
1424 BEAST_EXPECT(rv[jss::error] ==
"channelAmtMalformed");
1426 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel amount is malformed.");
1427 rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
"1000 ", sig);
1428 BEAST_EXPECT(rv[jss::error] ==
"channelAmtMalformed");
1430 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel amount is malformed.");
1431 rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
"x1000", sig);
1432 BEAST_EXPECT(rv[jss::error] ==
"channelAmtMalformed");
1434 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel amount is malformed.");
1435 rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
"x", sig);
1436 BEAST_EXPECT(rv[jss::error] ==
"channelAmtMalformed");
1438 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel amount is malformed.");
1439 rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
" ", sig);
1440 BEAST_EXPECT(rv[jss::error] ==
"channelAmtMalformed");
1442 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel amount is malformed.");
1443 rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
"1000 1000", sig);
1444 BEAST_EXPECT(rv[jss::error] ==
"channelAmtMalformed");
1446 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel amount is malformed.");
1447 rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
"1,000", sig);
1448 BEAST_EXPECT(rv[jss::error] ==
"channelAmtMalformed");
1450 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel amount is malformed.");
1451 rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
" 1000", sig);
1452 BEAST_EXPECT(rv[jss::error] ==
"channelAmtMalformed");
1454 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel amount is malformed.");
1455 rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
"", sig);
1456 BEAST_EXPECT(rv[jss::error] ==
"channelAmtMalformed");
1458 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel amount is malformed.");
1463 auto chan1StrBad = chan1Str;
1464 chan1StrBad.pop_back();
1465 auto rv = env.
rpc(
"channel_verify", pkAsHex, chan1StrBad,
"1000", sig);
1466 BEAST_EXPECT(rv[jss::error] ==
"channelMalformed");
1468 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel is malformed.");
1469 rv = env.
rpc(
"channel_authorize",
"alice", chan1StrBad,
"1000");
1470 BEAST_EXPECT(rv[jss::error] ==
"channelMalformed");
1472 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel is malformed.");
1474 chan1StrBad = chan1Str;
1475 chan1StrBad.push_back(
'0');
1476 rv = env.
rpc(
"channel_verify", pkAsHex, chan1StrBad,
"1000", sig);
1477 BEAST_EXPECT(rv[jss::error] ==
"channelMalformed");
1479 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel is malformed.");
1480 rv = env.
rpc(
"channel_authorize",
"alice", chan1StrBad,
"1000");
1481 BEAST_EXPECT(rv[jss::error] ==
"channelMalformed");
1483 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel is malformed.");
1485 chan1StrBad = chan1Str;
1486 chan1StrBad.back() =
'x';
1487 rv = env.
rpc(
"channel_verify", pkAsHex, chan1StrBad,
"1000", sig);
1488 BEAST_EXPECT(rv[jss::error] ==
"channelMalformed");
1490 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel is malformed.");
1491 rv = env.
rpc(
"channel_authorize",
"alice", chan1StrBad,
"1000");
1492 BEAST_EXPECT(rv[jss::error] ==
"channelMalformed");
1494 BEAST_EXPECT(rv[jss::error_message] ==
"Payment channel is malformed.");
1499 args[jss::amount] =
"2000";
1500 args[jss::channel_id] = 2000;
1501 args[jss::key_type] =
"secp256k1";
1502 args[jss::passphrase] =
"passphrase_can_be_anything";
1506 BEAST_EXPECT(ra[jss::error] ==
"invalidParams");
1508 BEAST_EXPECT(ra[jss::error_message] ==
"Invalid parameters.");
1513 args[jss::public_key] = chan1PkStr;
1514 args[jss::channel_id] = 2000;
1515 args[jss::amount] =
"1000";
1516 args[jss::signature] = sig;
1520 BEAST_EXPECT(rv[jss::error] ==
"invalidParams");
1522 BEAST_EXPECT(rv[jss::error_message] ==
"Invalid parameters.");
1526 auto const illFormedPk = chan1PkStr.
substr(0, chan1PkStr.
size() - 1);
1527 auto const rv = env.
rpc(
"channel_verify", illFormedPk, chan1Str,
"1000", sig);
1528 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1533 auto const illFormedPk = pkAsHex.substr(0, chan1PkStr.
size() - 1);
1534 auto const rv = env.
rpc(
"channel_verify", illFormedPk, chan1Str,
"1000", sig);
1535 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1540 auto const rs = env.
rpc(
"channel_authorize",
"alice", chan2Str,
"1000");
1541 auto const sig = rs[jss::result][jss::signature].
asString();
1542 BEAST_EXPECT(!sig.empty());
1544 auto const rv = env.
rpc(
"channel_verify", chan1PkStr, chan1Str,
"1000", sig);
1545 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1550 auto const rv = env.
rpc(
"channel_verify", pkAsHex, chan1Str,
"1000", sig);
1551 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1557 env(
create(charlie, alice, channelFunds, settleDelay, charlie.pk()));
1562 auto const r = env.
rpc(
"account_channels", charlie.human(), alice.human());
1563 BEAST_EXPECT(r[jss::result][jss::channels].
size() == 1);
1564 BEAST_EXPECT(r[jss::result][jss::channels][0u][jss::channel_id] == chan);
1565 BEAST_EXPECT(r[jss::result][jss::validated]);
1566 cpk = r[jss::result][jss::channels][0u][jss::public_key].asString();
1570 auto const rs = env.
rpc(
"channel_authorize",
"charlie", chan,
"1000");
1571 auto const sig = rs[jss::result][jss::signature].
asString();
1572 BEAST_EXPECT(!sig.empty());
1574 auto const rv = env.
rpc(
"channel_verify", cpk, chan,
"1000", sig);
1575 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1579 auto const rs1 = env.
rpc(
"channel_authorize",
"charlie",
"nyx", chan,
"1000");
1580 BEAST_EXPECT(rs1[jss::error] ==
"badKeyType");
1582 BEAST_EXPECT(rs1[jss::error_message] ==
"Bad key type.");
1586 auto const rs2 = env.
rpc(
"channel_authorize",
"charlie",
"secp256k1", chan,
"1000");
1587 auto const sig2 = rs2[jss::result][jss::signature].
asString();
1588 BEAST_EXPECT(!sig2.empty());
1590 auto const rv = env.
rpc(
"channel_verify", cpk, chan,
"1000", sig2);
1591 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1595 auto const rs3 = env.
rpc(
"channel_authorize",
"charlie",
"ed25519", chan,
"1000");
1596 auto const sig3 = rs3[jss::result][jss::signature].
asString();
1597 BEAST_EXPECT(!sig3.empty());
1599 auto const rv = env.
rpc(
"channel_verify", cpk, chan,
"1000", sig3);
1600 BEAST_EXPECT(rv[jss::result][jss::signature_verified].asBool());
1606 auto rs = env.
rpc(
"channel_authorize",
"alice", chan1Str,
"1000x");
1607 BEAST_EXPECT(rs[jss::error] ==
"channelAmtMalformed");
1609 BEAST_EXPECT(rs[jss::error_message] ==
"Payment channel amount is malformed.");
1610 rs = env.
rpc(
"channel_authorize",
"alice", chan1Str,
"x1000");
1611 BEAST_EXPECT(rs[jss::error] ==
"channelAmtMalformed");
1613 BEAST_EXPECT(rs[jss::error_message] ==
"Payment channel amount is malformed.");
1614 rs = env.
rpc(
"channel_authorize",
"alice", chan1Str,
"x");
1615 BEAST_EXPECT(rs[jss::error] ==
"channelAmtMalformed");
1617 BEAST_EXPECT(rs[jss::error_message] ==
"Payment channel amount is malformed.");
1621 args[jss::amount] =
"2000";
1622 args[jss::key_type] =
"secp256k1";
1623 args[jss::passphrase] =
"passphrase_can_be_anything";
1625 BEAST_EXPECT(rs[jss::error] ==
"invalidParams");
1627 BEAST_EXPECT(rs[jss::error_message] ==
"Missing field 'channel_id'.");
1632 args[jss::channel_id] = chan1Str;
1633 args[jss::key_type] =
"secp256k1";
1634 args[jss::passphrase] =
"passphrase_can_be_anything";
1636 BEAST_EXPECT(rs[jss::error] ==
"invalidParams");
1638 BEAST_EXPECT(rs[jss::error_message] ==
"Missing field 'amount'.");
1643 args[jss::amount] =
"2000";
1644 args[jss::channel_id] = chan1Str;
1645 args[jss::passphrase] =
"passphrase_can_be_anything";
1647 BEAST_EXPECT(rs[jss::error] ==
"invalidParams");
1649 BEAST_EXPECT(rs[jss::error_message] ==
"Missing field 'secret'.");
1654 args[jss::amount] =
"2000";
1655 args[jss::channel_id] = chan1Str;
1656 args[jss::key_type] =
"secp256k1";
1657 args[jss::passphrase] =
"passphrase_can_be_anything";
1658 args[jss::seed] =
"seed can be anything";
1660 BEAST_EXPECT(rs[jss::error] ==
"invalidParams");
1663 rs[jss::error_message] ==
1664 "Exactly one of the following must be specified: passphrase, secret, seed or "
1670 args[jss::amount] =
"2000";
1671 args[jss::channel_id] = chan1Str +
"1";
1672 args[jss::key_type] =
"secp256k1";
1673 args[jss::passphrase] =
"passphrase_can_be_anything";
1675 BEAST_EXPECT(rs[jss::error] ==
"channelMalformed");
1677 BEAST_EXPECT(rs[jss::error_message] ==
"Payment channel is malformed.");
1682 args[jss::amount] = 2000;
1683 args[jss::channel_id] = chan1Str;
1684 args[jss::key_type] =
"secp256k1";
1685 args[jss::passphrase] =
"passphrase_can_be_anything";
1687 BEAST_EXPECT(rs[jss::error] ==
"channelAmtMalformed");
1689 BEAST_EXPECT(rs[jss::error_message] ==
"Payment channel amount is malformed.");
1694 args[jss::amount] =
"TwoThousand";
1695 args[jss::channel_id] = chan1Str;
1696 args[jss::key_type] =
"secp256k1";
1697 args[jss::passphrase] =
"passphrase_can_be_anything";
1699 BEAST_EXPECT(rs[jss::error] ==
"channelAmtMalformed");
1701 BEAST_EXPECT(rs[jss::error_message] ==
"Payment channel amount is malformed.");
1950 auto const r = env.
rpc(
"json",
"channel_verify", txn);
1951 BEAST_EXPECT(r[
"result"][
"error"] ==
"publicMalformed");
1953 BEAST_EXPECT(r[
"result"][
"error_message"] ==
"Public key is malformed.");
1962 using namespace jtx;
1965 auto const alice =
Account(
"alice");
1966 auto const bob =
Account(
"bob");
1967 auto const settleDelay = 100s;
1968 auto const pk = alice.pk();
1970 auto const inOwnerDir =
1974 return std::find(ownerDir.begin(), ownerDir.end(), chan) != ownerDir.end();
1977 auto const ownerDirCount = [](ReadView
const& view,
Account const& acc) ->
std::size_t {
1984 Env env{*
this, features};
1985 env.
fund(
XRP(10000), alice, bob);
1986 env(
create(alice, bob,
XRP(1000), settleDelay, pk));
1989 BEAST_EXPECT(inOwnerDir(*env.current(), alice, chanSle));
1990 BEAST_EXPECT(ownerDirCount(*env.current(), alice) == 1);
1991 BEAST_EXPECT(inOwnerDir(*env.current(), bob, chanSle));
1992 BEAST_EXPECT(ownerDirCount(*env.current(), bob) == 1);
1994 env(
claim(bob, chan), Txflags(tfClose));
1996 BEAST_EXPECT(!inOwnerDir(*env.current(), alice, chanSle));
1997 BEAST_EXPECT(ownerDirCount(*env.current(), alice) == 0);
1998 BEAST_EXPECT(!inOwnerDir(*env.current(), bob, chanSle));
1999 BEAST_EXPECT(ownerDirCount(*env.current(), bob) == 0);
2005 Env env(*
this, features);
2006 env.fund(
XRP(10000), alice, bob);
2008 env(
create(alice, bob,
XRP(1000), settleDelay, pk));
2011 BEAST_EXPECT(inOwnerDir(*env.current(), alice, chanSle));
2012 BEAST_EXPECT(ownerDirCount(*env.current(), alice) == 1);
2013 BEAST_EXPECT(inOwnerDir(*env.current(), bob, chanSle));
2018 BEAST_EXPECT(!inOwnerDir(*env.current(), alice, chanSle));
2019 BEAST_EXPECT(ownerDirCount(*env.current(), alice) == 0);
2020 BEAST_EXPECT(!inOwnerDir(*env.current(), bob, chanSle));
2021 BEAST_EXPECT(ownerDirCount(*env.current(), bob) == 0);
2031 auto const rmAccount =
2036 for (
auto minRmSeq = env.seq(toRm) + 257; env.current()->seq() < minRmSeq;
2042 Fee(
drops(env.current()->fees().increment)),
2049 auto const alice =
Account(
"alice");
2050 auto const bob =
Account(
"bob");
2051 auto const carol =
Account(
"carol");
2054 Env env{*
this, features};
2055 env.fund(
XRP(10000), alice, bob, carol);
2059 auto const pk = alice.pk();
2060 auto const settleDelay = 100s;
2061 auto const chan =
channel(alice, bob, env.seq(alice));
2062 env(
create(alice, bob,
XRP(1000), settleDelay, pk));
2070 auto const feeDrops = env.current()->fees().base;
2073 BEAST_EXPECT(chanBal ==
XRP(0));
2074 BEAST_EXPECT(chanAmt ==
XRP(1000));
2076 auto const preBob = env.balance(bob);
2077 auto const delta =
XRP(50);
2078 auto reqBal = chanBal + delta;
2079 auto authAmt = reqBal +
XRP(100);
2080 assert(reqBal <= chanAmt);
2082 env(
claim(alice, chan, reqBal, authAmt));
2085 BEAST_EXPECT(
channelAmount(*env.current(), chan) == chanAmt);
2086 BEAST_EXPECT(env.balance(bob) == preBob + delta);
2089 auto const preAlice = env.balance(alice);
2090 env(
fund(alice, chan,
XRP(1000)));
2092 BEAST_EXPECT(env.balance(alice) == preAlice -
XRP(1000) - feeDrops);
2094 chanAmt = chanAmt +
XRP(1000);
2098 env(
claim(alice, chan), Txflags(tfClose));
2102 auto const closeTime = env.current()->header().parentCloseTime;
2103 auto const minExpiration = closeTime + settleDelay;
2104 env.close(minExpiration);
2115 using namespace jtx;
2117 Env env{*
this, features};
2118 auto const alice =
Account(
"alice");
2119 auto const bob =
Account(
"bob");
2120 auto const usda = alice[
"USD"];
2121 env.fund(
XRP(10000), alice, bob);
2126 std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
2128 std::uint32_t
const aliceSeq{env.seq(alice)};
2130 std::uint32_t bobTicketSeq{env.seq(bob) + 1};
2132 std::uint32_t
const bobSeq{env.seq(bob)};
2134 auto const pk = alice.pk();
2135 auto const settleDelay = 100s;
2136 auto const chan =
channel(alice, bob, aliceTicketSeq);
2138 env(
create(alice, bob,
XRP(1000), settleDelay, pk), ticket::Use(aliceTicketSeq++));
2140 env.require(
Tickets(alice, env.seq(alice) - aliceTicketSeq));
2141 BEAST_EXPECT(env.seq(alice) == aliceSeq);
2147 auto const preAlice = env.balance(alice);
2148 env(
fund(alice, chan,
XRP(1000)), ticket::Use(aliceTicketSeq++));
2150 env.require(
Tickets(alice, env.seq(alice) - aliceTicketSeq));
2151 BEAST_EXPECT(env.seq(alice) == aliceSeq);
2153 auto const feeDrops = env.current()->fees().base;
2154 BEAST_EXPECT(env.balance(alice) == preAlice -
XRP(1000) - feeDrops);
2159 BEAST_EXPECT(chanBal ==
XRP(0));
2160 BEAST_EXPECT(chanAmt ==
XRP(2000));
2164 auto const preBob = env.balance(bob);
2165 auto const delta =
XRP(500);
2166 auto const reqBal = chanBal + delta;
2167 auto const authAmt = reqBal +
XRP(100);
2168 assert(reqBal <= chanAmt);
2169 env(
claim(alice, chan, reqBal, authAmt), ticket::Use(aliceTicketSeq++));
2171 env.require(
Tickets(alice, env.seq(alice) - aliceTicketSeq));
2172 BEAST_EXPECT(env.seq(alice) == aliceSeq);
2175 BEAST_EXPECT(
channelAmount(*env.current(), chan) == chanAmt);
2176 BEAST_EXPECT(env.balance(bob) == preBob + delta);
2181 auto preBob = env.balance(bob);
2182 auto const delta =
XRP(500);
2183 auto const reqBal = chanBal + delta;
2184 auto const authAmt = reqBal +
XRP(100);
2185 assert(reqBal <= chanAmt);
2186 auto const sig =
signClaimAuth(alice.pk(), alice.sk(), chan, authAmt);
2187 env(
claim(bob, chan, reqBal, authAmt, Slice(sig), alice.pk()),
2188 ticket::Use(bobTicketSeq++));
2190 env.require(
Tickets(bob, env.seq(bob) - bobTicketSeq));
2191 BEAST_EXPECT(env.seq(bob) == bobSeq);
2194 BEAST_EXPECT(
channelAmount(*env.current(), chan) == chanAmt);
2195 auto const feeDrops = env.current()->fees().base;
2196 BEAST_EXPECT(env.balance(bob) == preBob + delta - feeDrops);
2200 preBob = env.balance(bob);
2202 env(
claim(bob, chan, reqBal, authAmt, Slice(sig), alice.pk()),
2203 ticket::Use(bobTicketSeq++),
2206 env.require(
Tickets(bob, env.seq(bob) - bobTicketSeq));
2207 BEAST_EXPECT(env.seq(bob) == bobSeq);
2210 BEAST_EXPECT(
channelAmount(*env.current(), chan) == chanAmt);
2211 BEAST_EXPECT(env.balance(bob) == preBob - feeDrops);
2215 auto const preBob = env.balance(bob);
2216 STAmount
const authAmt = chanBal +
XRP(500);
2217 STAmount
const reqAmt = authAmt +
drops(1);
2218 assert(reqAmt <= chanAmt);
2221 auto const sig =
signClaimAuth(alice.pk(), alice.sk(), chan, authAmt);
2222 env(
claim(bob, chan, reqAmt, authAmt, Slice(sig), alice.pk()),
2223 ticket::Use(bobTicketSeq),
2226 env.require(
Tickets(bob, env.seq(bob) - bobTicketSeq));
2227 BEAST_EXPECT(env.seq(bob) == bobSeq);
2230 BEAST_EXPECT(
channelAmount(*env.current(), chan) == chanAmt);
2231 BEAST_EXPECT(env.balance(bob) == preBob);
2237 env.require(
Tickets(bob, env.seq(bob) - bobTicketSeq));
2238 BEAST_EXPECT(env.seq(bob) == bobSeq);
2241 BEAST_EXPECT(
channelAmount(*env.current(), chan) == chanAmt);
2245 auto const preAlice = env.balance(alice);
2246 auto const preBob = env.balance(bob);
2247 env(
claim(bob, chan), Txflags(tfClose), ticket::Use(bobTicketSeq++));
2249 env.require(
Tickets(bob, env.seq(bob) - bobTicketSeq));
2250 BEAST_EXPECT(env.seq(bob) == bobSeq);
2253 auto const feeDrops = env.current()->fees().base;