xrpld
Loading...
Searching...
No Matches
PayChan_test.cpp
1
2#include <test/jtx/Account.h>
3#include <test/jtx/Env.h>
4#include <test/jtx/TestHelpers.h>
5#include <test/jtx/acctdelete.h>
6#include <test/jtx/amount.h>
7#include <test/jtx/balance.h> // IWYU pragma: keep
8#include <test/jtx/credentials.h>
9#include <test/jtx/deposit.h>
10#include <test/jtx/fee.h>
11#include <test/jtx/flags.h>
12#include <test/jtx/paychan.h>
13#include <test/jtx/ter.h>
14#include <test/jtx/ticket.h>
15#include <test/jtx/txflags.h>
16
17#include <xrpld/rpc/Context.h>
18#include <xrpld/rpc/Role.h>
19#include <xrpld/rpc/handlers/Handlers.h>
20
21#include <xrpl/basics/Slice.h>
22#include <xrpl/basics/base_uint.h>
23#include <xrpl/basics/chrono.h>
24#include <xrpl/basics/strHex.h>
25#include <xrpl/beast/unit_test/suite.h>
26#include <xrpl/beast/utility/Zero.h>
27#include <xrpl/core/Job.h>
28#include <xrpl/core/ServiceRegistry.h>
29#include <xrpl/json/json_value.h>
30#include <xrpl/json/to_string.h>
31#include <xrpl/ledger/ReadView.h>
32#include <xrpl/protocol/ApiVersion.h>
33#include <xrpl/protocol/ErrorCodes.h>
34#include <xrpl/protocol/Feature.h>
35#include <xrpl/protocol/Indexes.h>
36#include <xrpl/protocol/KeyType.h>
37#include <xrpl/protocol/LedgerFormats.h>
38#include <xrpl/protocol/PublicKey.h>
39#include <xrpl/protocol/SField.h>
40#include <xrpl/protocol/STAmount.h>
41#include <xrpl/protocol/SeqProxy.h>
42#include <xrpl/protocol/TER.h>
43#include <xrpl/protocol/TxFlags.h>
44#include <xrpl/protocol/jss.h>
45#include <xrpl/resource/Charge.h>
46#include <xrpl/resource/Consumer.h>
47#include <xrpl/resource/Fees.h>
48
49#include <algorithm>
50#include <cassert>
51#include <cstddef>
52#include <cstdint>
53#include <iterator>
54#include <optional>
55#include <set>
56#include <string>
57#include <string_view>
58#include <utility>
59#include <vector>
60
61namespace xrpl::test {
62using namespace jtx::paychan;
63
65{
67 channelKeyAndSle(ReadView const& view, jtx::Account const& account, jtx::Account const& dst)
68 {
69 auto const sle = view.read(keylet::account(account));
70 if (!sle)
71 return {};
72 auto const k =
73 keylet::payChannel(account, dst, SeqProxy::rawSequence((*sle)[sfSequence] - 1));
74 return {k.key, view.read(k)};
75 }
76
78 channelExpiration(ReadView const& view, UInt256 const& chan)
79 {
80 auto const slep = view.read({ltPAYCHAN, chan});
81 if (!slep)
82 return std::nullopt;
83 if (auto const r = (*slep)[~sfExpiration])
84 return r.value();
85 return std::nullopt;
86 }
87
88 void
90 {
91 testcase("simple");
92 using namespace jtx;
93 using namespace std::literals::chrono_literals;
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));
103 BEAST_EXPECT(channelBalance(*env.current(), chan) == XRP(0));
104 BEAST_EXPECT(channelAmount(*env.current(), chan) == XRP(1000));
105
106 {
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);
111 }
112
113 auto chanBal = channelBalance(*env.current(), chan);
114 auto const chanAmt = channelAmount(*env.current(), chan);
115 BEAST_EXPECT(chanBal == XRP(0));
116 BEAST_EXPECT(chanAmt == XRP(2000));
117
118 {
119 // bad amounts (non-xrp, negative amounts)
120 env(create(alice, bob, usda(1000), settleDelay, pk), Ter(temBAD_AMOUNT));
121 env(fund(alice, chan, usda(1000)), Ter(temBAD_AMOUNT));
122 env(create(alice, bob, XRP(-1000), settleDelay, pk), Ter(temBAD_AMOUNT));
123 env(fund(alice, chan, XRP(-1000)), Ter(temBAD_AMOUNT));
124 }
125
126 // invalid account
127 env(create(alice, "noAccount", XRP(1000), settleDelay, pk), Ter(tecNO_DST));
128 // can't create channel to the same account
129 env(create(alice, alice, XRP(1000), settleDelay, pk), Ter(temDST_IS_SRC));
130 // invalid channel
131
132 env(fund(alice, channel(alice, "noAccount", env.seq(alice) - 1), XRP(1000)),
134 // not enough funds
135 env(create(alice, bob, XRP(10000), settleDelay, pk), Ter(tecUNFUNDED));
136
137 {
138 // No signature claim with bad amounts (negative and non-xrp)
139 auto const iou = usda(100).value();
140 auto const negXRP = XRP(-100).value();
141 auto const posXRP = XRP(100).value();
142 env(claim(alice, chan, iou, iou), Ter(temBAD_AMOUNT));
143 env(claim(alice, chan, posXRP, iou), Ter(temBAD_AMOUNT));
144 env(claim(alice, chan, iou, posXRP), Ter(temBAD_AMOUNT));
145 env(claim(alice, chan, negXRP, negXRP), Ter(temBAD_AMOUNT));
146 env(claim(alice, chan, posXRP, negXRP), Ter(temBAD_AMOUNT));
147 env(claim(alice, chan, negXRP, posXRP), Ter(temBAD_AMOUNT));
148 }
149 {
150 // No signature claim more than authorized
151 auto const delta = XRP(500);
152 auto const reqBal = chanBal + delta;
153 auto const authAmt = reqBal + XRP(-100);
154 assert(reqBal <= chanAmt);
155 env(claim(alice, chan, reqBal, authAmt), Ter(temBAD_AMOUNT));
156 }
157 {
158 // No signature needed since the owner is claiming
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));
165 BEAST_EXPECT(channelBalance(*env.current(), chan) == reqBal);
166 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
167 BEAST_EXPECT(env.balance(bob) == preBob + delta);
168 chanBal = reqBal;
169 }
170 {
171 // Claim with signature
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()));
179 BEAST_EXPECT(channelBalance(*env.current(), chan) == reqBal);
180 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
181 auto const feeDrops = env.current()->fees().base;
182 BEAST_EXPECT(env.balance(bob) == preBob + delta - feeDrops);
183 chanBal = reqBal;
184
185 // claim again
186 preBob = env.balance(bob);
187 env(claim(bob, chan, reqBal, authAmt, Slice(sig), alice.pk()),
189 BEAST_EXPECT(channelBalance(*env.current(), chan) == chanBal);
190 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
191 BEAST_EXPECT(env.balance(bob) == preBob - feeDrops);
192 }
193 {
194 // Try to claim more than authorized
195 auto const preBob = env.balance(bob);
196 STAmount const authAmt = chanBal + XRP(500);
197 STAmount const reqAmt = authAmt + STAmount{1};
198 assert(reqAmt <= chanAmt);
199 auto const sig = signClaimAuth(alice.pk(), alice.sk(), chan, authAmt);
200 env(claim(bob, chan, reqAmt, authAmt, Slice(sig), alice.pk()), Ter(temBAD_AMOUNT));
201 BEAST_EXPECT(channelBalance(*env.current(), chan) == chanBal);
202 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
203 BEAST_EXPECT(env.balance(bob) == preBob);
204 }
205
206 // Dst tries to fund the channel
207 env(fund(bob, chan, XRP(1000)), Ter(tecNO_PERMISSION));
208 BEAST_EXPECT(channelBalance(*env.current(), chan) == chanBal);
209 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
210
211 {
212 // Wrong signing key
213 auto const sig = signClaimAuth(bob.pk(), bob.sk(), chan, XRP(1500));
214 env(claim(bob, chan, XRP(1500).value(), XRP(1500).value(), Slice(sig), bob.pk()),
216 BEAST_EXPECT(channelBalance(*env.current(), chan) == chanBal);
217 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
218 }
219 {
220 // Bad signature
221 auto const sig = signClaimAuth(bob.pk(), bob.sk(), chan, XRP(1500));
222 env(claim(bob, chan, XRP(1500).value(), XRP(1500).value(), Slice(sig), alice.pk()),
224 BEAST_EXPECT(channelBalance(*env.current(), chan) == chanBal);
225 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
226 }
227 {
228 // Dst closes channel
229 auto const preAlice = env.balance(alice);
230 auto const preBob = env.balance(bob);
231 env(claim(bob, chan), Txflags(tfClose));
232 BEAST_EXPECT(!channelExists(*env.current(), chan));
233 auto const feeDrops = env.current()->fees().base;
234 auto const delta = chanAmt - chanBal;
235 assert(delta > beast::kZero);
236 BEAST_EXPECT(env.balance(alice) == preAlice + delta);
237 BEAST_EXPECT(env.balance(bob) == preBob - feeDrops);
238 }
239 }
240
241 void
243 {
244 testcase("Disallow Incoming Flag");
245 using namespace jtx;
246
247 using namespace std::literals::chrono_literals;
248 Env env{*this, features};
249 auto const alice = Account("alice");
250 auto const bob = Account("bob");
251 auto const cho = Account("cho");
252 env.fund(XRP(10000), alice, bob, cho);
253 auto const pk = alice.pk();
254 auto const settleDelay = 100s;
255
256 // set flag on bob only
257 env(fset(bob, asfDisallowIncomingPayChan));
258 env.close();
259
260 // channel creation from alice to bob is disallowed
261 {
262 auto const chan = channel(alice, bob, env.seq(alice));
263 env(create(alice, bob, XRP(1000), settleDelay, pk), Ter(tecNO_PERMISSION));
264 BEAST_EXPECT(!channelExists(*env.current(), chan));
265 }
266
267 // set flag on alice also
268 env(fset(alice, asfDisallowIncomingPayChan));
269 env.close();
270
271 // channel creation from bob to alice is now disallowed
272 {
273 auto const chan = channel(bob, alice, env.seq(bob));
274 env(create(bob, alice, XRP(1000), settleDelay, pk), Ter(tecNO_PERMISSION));
275 BEAST_EXPECT(!channelExists(*env.current(), chan));
276 }
277
278 // remove flag from bob
279 env(fclear(bob, asfDisallowIncomingPayChan));
280 env.close();
281
282 // now the channel between alice and bob can exist
283 {
284 auto const chan = channel(alice, bob, env.seq(alice));
285 env(create(alice, bob, XRP(1000), settleDelay, pk), Ter(tesSUCCESS));
286 BEAST_EXPECT(channelExists(*env.current(), chan));
287 }
288
289 // a channel from cho to alice isn't allowed
290 {
291 auto const chan = channel(cho, alice, env.seq(cho));
292 env(create(cho, alice, XRP(1000), settleDelay, pk), Ter(tecNO_PERMISSION));
293 BEAST_EXPECT(!channelExists(*env.current(), chan));
294 }
295
296 // remove flag from alice
297 env(fclear(alice, asfDisallowIncomingPayChan));
298 env.close();
299
300 // now a channel from cho to alice is allowed
301 {
302 auto const chan = channel(cho, alice, env.seq(cho));
303 env(create(cho, alice, XRP(1000), settleDelay, pk), Ter(tesSUCCESS));
304 BEAST_EXPECT(channelExists(*env.current(), chan));
305 }
306 }
307
308 void
310 {
311 testcase("cancel after");
312 using namespace jtx;
313 using namespace std::literals::chrono_literals;
314 auto const alice = Account("alice");
315 auto const bob = Account("bob");
316 auto const carol = Account("carol");
317 {
318 // If dst claims after cancel after, channel closes
319 Env env{*this, features};
320 env.fund(XRP(10000), alice, bob);
321 auto const pk = alice.pk();
322 auto const settleDelay = 100s;
323 NetClock::time_point const cancelAfter =
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));
328 BEAST_EXPECT(channelExists(*env.current(), chan));
329 env.close(cancelAfter);
330 {
331 // dst cannot claim after cancelAfter
332 auto const chanBal = channelBalance(*env.current(), chan);
333 auto const chanAmt = channelAmount(*env.current(), chan);
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;
343 BEAST_EXPECT(!channelExists(*env.current(), chan));
344 BEAST_EXPECT(env.balance(bob) == preBob - feeDrops);
345 BEAST_EXPECT(env.balance(alice) == preAlice + channelFunds);
346 }
347 }
348 {
349 // Third party can close after cancel after
350 Env env{*this, features};
351 env.fund(XRP(10000), alice, bob, carol);
352 auto const pk = alice.pk();
353 auto const settleDelay = 100s;
354 NetClock::time_point const cancelAfter =
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));
359 BEAST_EXPECT(channelExists(*env.current(), chan));
360 // third party close before cancelAfter
361 env(claim(carol, chan), Txflags(tfClose), Ter(tecNO_PERMISSION));
362 BEAST_EXPECT(channelExists(*env.current(), chan));
363 env.close(cancelAfter);
364 // third party close after cancelAfter
365 auto const preAlice = env.balance(alice);
366 env(claim(carol, chan), Txflags(tfClose));
367 BEAST_EXPECT(!channelExists(*env.current(), chan));
368 BEAST_EXPECT(env.balance(alice) == preAlice + channelFunds);
369 }
370 // fixPayChanCancelAfter
371 // CancelAfter should be greater than close time
372 {
373 for (bool const withFixPayChan : {true, false})
374 {
375 auto const amend = withFixPayChan ? features : features - fixPayChanCancelAfter;
376 Env env{*this, amend};
377 env.fund(XRP(10000), alice, bob);
378 env.close();
379
380 auto const pk = alice.pk();
381 auto const settleDelay = 100s;
382 auto const channelFunds = XRP(1000);
383 NetClock::time_point const cancelAfter =
384 env.current()->header().parentCloseTime - 1s;
385 auto const txResult = withFixPayChan ? Ter(tecEXPIRED) : Ter(tesSUCCESS);
386 env(create(alice, bob, channelFunds, settleDelay, pk, cancelAfter), txResult);
387 }
388 }
389 // fixPayChanCancelAfter
390 // CancelAfter can be equal to the close time
391 {
392 for (bool const withFixPayChan : {true, false})
393 {
394 auto const amend = withFixPayChan ? features : features - fixPayChanCancelAfter;
395 Env env{*this, amend};
396 env.fund(XRP(10000), alice, bob);
397 env.close();
398
399 auto const pk = alice.pk();
400 auto const settleDelay = 100s;
401 auto const channelFunds = XRP(1000);
402 NetClock::time_point const cancelAfter = env.current()->header().parentCloseTime;
403 env(create(alice, bob, channelFunds, settleDelay, pk, cancelAfter),
404 Ter(tesSUCCESS));
405 }
406 }
407 }
408
409 void
411 {
412 testcase("expiration");
413 using namespace jtx;
414 using namespace std::literals::chrono_literals;
415 Env env{*this, features};
416 auto const alice = Account("alice");
417 auto const bob = Account("bob");
418 auto const carol = Account("carol");
419 env.fund(XRP(10000), alice, bob, carol);
420 auto const pk = alice.pk();
421 auto const settleDelay = 3600s;
422 auto const closeTime = env.current()->header().parentCloseTime;
423 auto const minExpiration = closeTime + settleDelay;
424 NetClock::time_point const cancelAfter = closeTime + 7200s;
425 auto const channelFunds = XRP(1000);
426 auto const chan = channel(alice, bob, env.seq(alice));
427 env(create(alice, bob, channelFunds, settleDelay, pk, cancelAfter));
428 BEAST_EXPECT(channelExists(*env.current(), chan));
429 BEAST_EXPECT(!channelExpiration(*env.current(), chan));
430 // Owner closes, will close after settleDelay
431 env(claim(alice, chan), Txflags(tfClose));
432 auto const counts = [](auto const& t) { return t.time_since_epoch().count(); };
433 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
434 BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration));
435 // increase the expiration time
436 env(fund(alice, chan, XRP(1), NetClock::time_point{minExpiration + 100s}));
437 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
438 BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration) + 100);
439 // decrease the expiration, but still above minExpiration
440 env(fund(alice, chan, XRP(1), NetClock::time_point{minExpiration + 50s}));
441 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
442 BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration) + 50);
443 // decrease the expiration below minExpiration
444 env(fund(alice, chan, XRP(1), NetClock::time_point{minExpiration - 50s}),
446 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
447 BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration) + 50);
448 env(claim(bob, chan), Txflags(tfRenew), Ter(tecNO_PERMISSION));
449 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
450 BEAST_EXPECT(*channelExpiration(*env.current(), chan) == counts(minExpiration) + 50);
451 env(claim(alice, chan), Txflags(tfRenew));
452 BEAST_EXPECT(!channelExpiration(*env.current(), chan));
453 // decrease the expiration below minExpiration
454 env(fund(alice, chan, XRP(1), NetClock::time_point{minExpiration - 50s}),
456 BEAST_EXPECT(!channelExpiration(*env.current(), chan));
457 env(fund(alice, chan, XRP(1), NetClock::time_point{minExpiration}));
458 env.close(minExpiration);
459 // Try to extend the expiration after the expiration has already passed
460 env(fund(alice, chan, XRP(1), NetClock::time_point{minExpiration + 1000s}));
461 BEAST_EXPECT(!channelExists(*env.current(), chan));
462 }
463
464 void
466 {
467 testcase("settle delay");
468 using namespace jtx;
469 using namespace std::literals::chrono_literals;
470 Env env{*this, features};
471 auto const alice = Account("alice");
472 auto const bob = Account("bob");
473 env.fund(XRP(10000), alice, bob);
474 auto const pk = alice.pk();
475 auto const settleDelay = 3600s;
476 NetClock::time_point const settleTimepoint =
477 env.current()->header().parentCloseTime + settleDelay;
478 auto const channelFunds = XRP(1000);
479 auto const chan = channel(alice, bob, env.seq(alice));
480 env(create(alice, bob, channelFunds, settleDelay, pk));
481 BEAST_EXPECT(channelExists(*env.current(), chan));
482 // Owner closes, will close after settleDelay
483 env(claim(alice, chan), Txflags(tfClose));
484 BEAST_EXPECT(channelExists(*env.current(), chan));
485 env.close(settleTimepoint - (settleDelay / 2));
486 {
487 // receiver can still claim
488 auto const chanBal = channelBalance(*env.current(), chan);
489 auto const chanAmt = channelAmount(*env.current(), chan);
490 auto const preBob = env.balance(bob);
491 auto const delta = XRP(500);
492 auto const reqBal = chanBal + delta;
493 auto const authAmt = reqBal + XRP(100);
494 assert(reqBal <= chanAmt);
495 auto const sig = signClaimAuth(alice.pk(), alice.sk(), chan, authAmt);
496 env(claim(bob, chan, reqBal, authAmt, Slice(sig), alice.pk()));
497 BEAST_EXPECT(channelBalance(*env.current(), chan) == reqBal);
498 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
499 auto const feeDrops = env.current()->fees().base;
500 BEAST_EXPECT(env.balance(bob) == preBob + delta - feeDrops);
501 }
502 env.close(settleTimepoint);
503 {
504 // past settleTime, channel will close
505 auto const chanBal = channelBalance(*env.current(), chan);
506 auto const chanAmt = channelAmount(*env.current(), chan);
507 auto const preAlice = env.balance(alice);
508 auto const preBob = env.balance(bob);
509 auto const delta = XRP(500);
510 auto const reqBal = chanBal + delta;
511 auto const authAmt = reqBal + XRP(100);
512 assert(reqBal <= chanAmt);
513 auto const sig = signClaimAuth(alice.pk(), alice.sk(), chan, authAmt);
514 env(claim(bob, chan, reqBal, authAmt, Slice(sig), alice.pk()));
515 BEAST_EXPECT(!channelExists(*env.current(), chan));
516 auto const feeDrops = env.current()->fees().base;
517 BEAST_EXPECT(env.balance(alice) == preAlice + chanAmt - chanBal);
518 BEAST_EXPECT(env.balance(bob) == preBob - feeDrops);
519 }
520 }
521
522 void
524 {
525 testcase("close dry");
526 using namespace jtx;
527 using namespace std::literals::chrono_literals;
528 Env env{*this, features};
529 auto const alice = Account("alice");
530 auto const bob = Account("bob");
531 env.fund(XRP(10000), alice, bob);
532 auto const pk = alice.pk();
533 auto const settleDelay = 3600s;
534 auto const channelFunds = XRP(1000);
535 auto const chan = channel(alice, bob, env.seq(alice));
536 env(create(alice, bob, channelFunds, settleDelay, pk));
537 BEAST_EXPECT(channelExists(*env.current(), chan));
538 // Owner tries to close channel, but it will remain open (settle delay)
539 env(claim(alice, chan), Txflags(tfClose));
540 BEAST_EXPECT(channelExists(*env.current(), chan));
541 {
542 // claim the entire amount
543 auto const preBob = env.balance(bob);
544 env(claim(alice, chan, channelFunds.value(), channelFunds.value()));
545 BEAST_EXPECT(channelBalance(*env.current(), chan) == channelFunds);
546 BEAST_EXPECT(env.balance(bob) == preBob + channelFunds);
547 }
548 auto const preAlice = env.balance(alice);
549 // Channel is now dry, can close before expiration date
550 env(claim(alice, chan), Txflags(tfClose));
551 BEAST_EXPECT(!channelExists(*env.current(), chan));
552 auto const feeDrops = env.current()->fees().base;
553 BEAST_EXPECT(env.balance(alice) == preAlice - feeDrops);
554 }
555
556 void
558 {
559 // auth amount defaults to balance if not present
560 testcase("default amount");
561 using namespace jtx;
562 using namespace std::literals::chrono_literals;
563 Env env{*this, features};
564 auto const alice = Account("alice");
565 auto const bob = Account("bob");
566 env.fund(XRP(10000), alice, bob);
567 auto const pk = alice.pk();
568 auto const settleDelay = 3600s;
569 auto const channelFunds = XRP(1000);
570 auto const chan = channel(alice, bob, env.seq(alice));
571 env(create(alice, bob, channelFunds, settleDelay, pk));
572 BEAST_EXPECT(channelExists(*env.current(), chan));
573 // Owner tries to close channel, but it will remain open (settle delay)
574 env(claim(alice, chan), Txflags(tfClose));
575 BEAST_EXPECT(channelExists(*env.current(), chan));
576 {
577 auto chanBal = channelBalance(*env.current(), chan);
578 auto const chanAmt = channelAmount(*env.current(), chan);
579 auto const preBob = env.balance(bob);
580
581 auto const delta = XRP(500);
582 auto const reqBal = chanBal + delta;
583 assert(reqBal <= chanAmt);
584 auto const sig = signClaimAuth(alice.pk(), alice.sk(), chan, reqBal);
585 env(claim(bob, chan, reqBal, std::nullopt, Slice(sig), alice.pk()));
586 BEAST_EXPECT(channelBalance(*env.current(), chan) == reqBal);
587 auto const feeDrops = env.current()->fees().base;
588 BEAST_EXPECT(env.balance(bob) == preBob + delta - feeDrops);
589 chanBal = reqBal;
590 }
591 {
592 // Claim again
593 auto chanBal = channelBalance(*env.current(), chan);
594 auto const chanAmt = channelAmount(*env.current(), chan);
595 auto const preBob = env.balance(bob);
596
597 auto const delta = XRP(500);
598 auto const reqBal = chanBal + delta;
599 assert(reqBal <= chanAmt);
600 auto const sig = signClaimAuth(alice.pk(), alice.sk(), chan, reqBal);
601 env(claim(bob, chan, reqBal, std::nullopt, Slice(sig), alice.pk()));
602 BEAST_EXPECT(channelBalance(*env.current(), chan) == reqBal);
603 auto const feeDrops = env.current()->fees().base;
604 BEAST_EXPECT(env.balance(bob) == preBob + delta - feeDrops);
605 chanBal = reqBal;
606 }
607 }
608
609 void
611 {
612 // auth amount defaults to balance if not present
613 testcase("Disallow XRP");
614 using namespace jtx;
615 using namespace std::literals::chrono_literals;
616
617 auto const alice = Account("alice");
618 auto const bob = Account("bob");
619 {
620 // Create a channel where dst disallows XRP. Ignore that flag,
621 // since it's just advisory.
622 Env env{*this, features};
623 env.fund(XRP(10000), alice, bob);
624 env(fset(bob, asfDisallowXRP));
625 auto const chan = channel(alice, bob, env.seq(alice));
626 env(create(alice, bob, XRP(1000), 3600s, alice.pk()));
627 BEAST_EXPECT(channelExists(*env.current(), chan));
628 }
629
630 {
631 // Claim to a channel where dst disallows XRP (channel is
632 // created before disallow xrp is set). Ignore that flag
633 // since it is just advisory.
634 Env env{*this, features};
635 env.fund(XRP(10000), alice, bob);
636 auto const chan = channel(alice, bob, env.seq(alice));
637 env(create(alice, bob, XRP(1000), 3600s, alice.pk()));
638 BEAST_EXPECT(channelExists(*env.current(), chan));
639
640 env(fset(bob, asfDisallowXRP));
641 auto const reqBal = XRP(500).value();
642 env(claim(alice, chan, reqBal, reqBal));
643 }
644 }
645
646 void
648 {
649 // auth amount defaults to balance if not present
650 testcase("Dst Tag");
651 using namespace jtx;
652 using namespace std::literals::chrono_literals;
653 // Create a channel where dst disallows XRP
654 Env env{*this, features};
655 auto const alice = Account("alice");
656 auto const bob = Account("bob");
657 env.fund(XRP(10000), alice, bob);
658 env(fset(bob, asfRequireDest));
659 auto const pk = alice.pk();
660 auto const settleDelay = 3600s;
661 auto const channelFunds = XRP(1000);
662 {
663 auto const chan = channel(alice, bob, env.seq(alice));
664 env(create(alice, bob, channelFunds, settleDelay, pk), Ter(tecDST_TAG_NEEDED));
665 BEAST_EXPECT(!channelExists(*env.current(), chan));
666 }
667 {
668 auto const chan = channel(alice, bob, env.seq(alice));
669 env(create(alice, bob, channelFunds, settleDelay, pk, std::nullopt, 1));
670 BEAST_EXPECT(channelExists(*env.current(), chan));
671 }
672 }
673
674 void
676 {
677 testcase("Deposit Authorization");
678 using namespace jtx;
679 using namespace std::literals::chrono_literals;
680
681 auto const alice = Account("alice");
682 auto const bob = Account("bob");
683 auto const carol = Account("carol");
684 auto const usda = alice["USD"];
685 {
686 Env env{*this, features};
687 env.fund(XRP(10000), alice, bob, carol);
688
689 env(fset(bob, asfDepositAuth));
690 env.close();
691
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));
696 env.close();
697
698 BEAST_EXPECT(channelBalance(*env.current(), chan) == XRP(0));
699 BEAST_EXPECT(channelAmount(*env.current(), chan) == XRP(1000));
700
701 // alice can add more funds to the channel even though bob has
702 // asfDepositAuth set.
703 env(fund(alice, chan, XRP(1000)));
704 env.close();
705
706 // alice claims. Fails because bob's lsfDepositAuth flag is set.
707 env(claim(alice, chan, XRP(500).value(), XRP(500).value()), Ter(tecNO_PERMISSION));
708 env.close();
709
710 // Claim with signature
711 auto const baseFee = env.current()->fees().base;
712 auto const preBob = env.balance(bob);
713 {
714 auto const delta = XRP(500).value();
715 auto const sig = signClaimAuth(pk, alice.sk(), chan, delta);
716
717 // alice claims with signature. Fails since bob has
718 // lsfDepositAuth flag set.
719 env(claim(alice, chan, delta, delta, Slice(sig), pk), Ter(tecNO_PERMISSION));
720 env.close();
721 BEAST_EXPECT(env.balance(bob) == preBob);
722
723 // bob claims but omits the signature. Fails because only
724 // alice can claim without a signature.
725 env(claim(bob, chan, delta, delta), Ter(temBAD_SIGNATURE));
726 env.close();
727
728 // bob claims with signature. Succeeds even though bob's
729 // lsfDepositAuth flag is set since bob submitted the
730 // transaction.
731 env(claim(bob, chan, delta, delta, Slice(sig), pk));
732 env.close();
733 BEAST_EXPECT(env.balance(bob) == preBob + delta - baseFee);
734 }
735 {
736 // Explore the limits of deposit pre-authorization.
737 auto const delta = XRP(600).value();
738 auto const sig = signClaimAuth(pk, alice.sk(), chan, delta);
739
740 // carol claims and fails. Only channel participants (bob or
741 // alice) may claim.
742 env(claim(carol, chan, delta, delta, Slice(sig), pk), Ter(tecNO_PERMISSION));
743 env.close();
744
745 // bob preauthorizes carol for deposit. But after that carol
746 // still can't claim since only channel participants may claim.
747 env(deposit::auth(bob, carol));
748 env.close();
749
750 env(claim(carol, chan, delta, delta, Slice(sig), pk), Ter(tecNO_PERMISSION));
751
752 // Since alice is not preauthorized she also may not claim
753 // for bob.
754 env(claim(alice, chan, delta, delta, Slice(sig), pk), Ter(tecNO_PERMISSION));
755 env.close();
756
757 // However if bob preauthorizes alice for deposit then she can
758 // successfully submit a claim.
759 env(deposit::auth(bob, alice));
760 env.close();
761
762 env(claim(alice, chan, delta, delta, Slice(sig), pk));
763 env.close();
764
765 BEAST_EXPECT(env.balance(bob) == preBob + delta - (3 * baseFee));
766 }
767 {
768 // bob removes pre-authorization of alice. Once again she
769 // cannot submit a claim.
770 auto const delta = XRP(800).value();
771
772 env(deposit::unauth(bob, alice));
773 env.close();
774
775 // alice claims and fails since she is no longer preauthorized.
776 env(claim(alice, chan, delta, delta), Ter(tecNO_PERMISSION));
777 env.close();
778
779 // bob clears lsfDepositAuth. Now alice can claim.
780 env(fclear(bob, asfDepositAuth));
781 env.close();
782
783 // alice claims successfully.
784 env(claim(alice, chan, delta, delta));
785 env.close();
786 BEAST_EXPECT(env.balance(bob) == preBob + XRP(800) - (5 * baseFee));
787 }
788 }
789 }
790
791 void
793 {
794 testcase("Deposit Authorization with Credentials");
795 using namespace jtx;
796 using namespace std::literals::chrono_literals;
797
798 char const credType[] = "abcde";
799
800 Account const alice("alice");
801 Account const bob("bob");
802 Account const carol("carol");
803 Account const dillon("dillon");
804 Account const zelda("zelda");
805
806 {
807 Env env{*this};
808 env.fund(XRP(10000), alice, bob, carol, dillon, zelda);
809
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));
814 env.close();
815
816 // alice add funds to the channel
817 env(fund(alice, chan, XRP(1000)));
818 env.close();
819
820 std::string const credBadIdx =
821 "D007AE4B6E1274B4AF872588267B810C2F82716726351D1C7D38D3E5499FC6"
822 "E1";
823
824 auto const delta = XRP(500).value();
825
826 { // create credentials
827 auto jv = credentials::create(alice, carol, credType);
828 uint32_t const t =
829 env.current()->header().parentCloseTime.time_since_epoch().count() + 100;
830 jv[sfExpiration.jsonName] = t;
831 env(jv);
832 env.close();
833 }
834
835 auto const jv = credentials::ledgerEntry(env, alice, carol, credType);
836 std::string const credIdx = jv[jss::result][jss::index].asString();
837
838 // Bob require pre-authorization
839 env(fset(bob, asfDepositAuth));
840 env.close();
841
842 // Fail, credentials not accepted
843 env(claim(alice, chan, delta, delta),
844 credentials::Ids({credIdx}),
846 env.close();
847
848 env(credentials::accept(alice, carol, credType));
849 env.close();
850
851 // Fail, no depositPreauth object
852 env(claim(alice, chan, delta, delta),
853 credentials::Ids({credIdx}),
855 env.close();
856
857 // Setup deposit authorization
858 env(deposit::authCredentials(bob, {{.issuer = carol, .credType = credType}}));
859 env.close();
860
861 // Fail, credentials doesn’t belong to root account
862 env(claim(dillon, chan, delta, delta),
863 credentials::Ids({credIdx}),
865
866 // Fails because bob's lsfDepositAuth flag is set.
867 env(claim(alice, chan, delta, delta), Ter(tecNO_PERMISSION));
868
869 // Fail, bad credentials index.
870 env(claim(alice, chan, delta, delta),
871 credentials::Ids({credBadIdx}),
873
874 // Fail, empty credentials
875 env(claim(alice, chan, delta, delta), credentials::Ids({}), Ter(temMALFORMED));
876
877 {
878 // claim fails cause of expired credentials
879
880 // Every cycle +10sec.
881 for (int i = 0; i < 10; ++i)
882 env.close();
883
884 env(claim(alice, chan, delta, delta), credentials::Ids({credIdx}), Ter(tecEXPIRED));
885 env.close();
886 }
887
888 { // create credentials once more
889 env(credentials::create(alice, carol, credType));
890 env.close();
891 env(credentials::accept(alice, carol, credType));
892 env.close();
893
894 auto const jv = credentials::ledgerEntry(env, alice, carol, credType);
895 std::string const credIdx = jv[jss::result][jss::index].asString();
896
897 // Success
898 env(claim(alice, chan, delta, delta), credentials::Ids({credIdx}));
899 }
900 }
901
902 {
903 Env env{*this};
904 env.fund(XRP(10000), alice, bob, carol, dillon, zelda);
905
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));
910 env.close();
911
912 // alice add funds to the channel
913 env(fund(alice, chan, XRP(1000)));
914 env.close();
915
916 auto const delta = XRP(500).value();
917
918 { // create credentials
919 env(credentials::create(alice, carol, credType));
920 env.close();
921 env(credentials::accept(alice, carol, credType));
922 env.close();
923 }
924
925 auto const jv = credentials::ledgerEntry(env, alice, carol, credType);
926 std::string const credIdx = jv[jss::result][jss::index].asString();
927
928 // Succeed, lsfDepositAuth is not set
929 env(claim(alice, chan, delta, delta), credentials::Ids({credIdx}));
930 env.close();
931 }
932
933 {
934 // Credentials amendment not enabled
935 Env env(*this, testableAmendments() - featureCredentials);
936 env.fund(XRP(5000), "alice", "bob");
937 env.close();
938
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));
943 env.close();
944
945 env(fund(alice, chan, XRP(1000)));
946 env.close();
947 std::string const credIdx =
948 "48004829F915654A81B11C4AB8218D96FED67F209B58328A72314FB6EA288B"
949 "E4";
950
951 // can't claim with old DepositPreauth because rule is not enabled.
952 env(fset(bob, asfDepositAuth));
953 env.close();
954 env(deposit::auth(bob, alice));
955 env.close();
956
957 env(claim(alice, chan, XRP(500).value(), XRP(500).value()),
958 credentials::Ids({credIdx}),
960 }
961 }
962
963 void
965 {
966 // auth amount defaults to balance if not present
967 testcase("Multiple channels to the same account");
968 using namespace jtx;
969 using namespace std::literals::chrono_literals;
970 Env env{*this, features};
971 auto const alice = Account("alice");
972 auto const bob = Account("bob");
973 env.fund(XRP(10000), alice, bob);
974 auto const pk = alice.pk();
975 auto const settleDelay = 3600s;
976 auto const channelFunds = XRP(1000);
977 auto const chan1 = channel(alice, bob, env.seq(alice));
978 env(create(alice, bob, channelFunds, settleDelay, pk));
979 BEAST_EXPECT(channelExists(*env.current(), chan1));
980 auto const chan2 = channel(alice, bob, env.seq(alice));
981 env(create(alice, bob, channelFunds, settleDelay, pk));
982 BEAST_EXPECT(channelExists(*env.current(), chan2));
983 BEAST_EXPECT(chan1 != chan2);
984 }
985
986 void
988 {
989 testcase("AccountChannels RPC");
990
991 using namespace jtx;
992 using namespace std::literals::chrono_literals;
993 Env env{*this, features};
994 auto const alice = Account("alice");
995 auto const bob = Account("bob");
996 auto const charlie = Account("charlie", KeyType::Ed25519);
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);
1001 auto const chan1Str = to_string(channel(alice, bob, env.seq(alice)));
1002 env(create(alice, bob, channelFunds, settleDelay, pk));
1003 env.close();
1004 {
1005 // test account non-string
1006 auto const testInvalidAccountParam = [&](auto const& param) {
1007 json::Value params;
1008 params[jss::account] = param;
1009 auto const jrr =
1010 env.rpc("json", "account_channels", to_string(params))[jss::result];
1011 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1012 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1013 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'account'.");
1014 };
1015
1016 testInvalidAccountParam(1);
1017 testInvalidAccountParam(1.1);
1018 testInvalidAccountParam(true);
1019 testInvalidAccountParam(json::Value(json::ValueType::Null));
1020 testInvalidAccountParam(json::Value(json::ValueType::Object));
1021 testInvalidAccountParam(json::Value(json::ValueType::Array));
1022 }
1023 {
1024 // test destination_account non-string
1025 auto const testInvalidDestAccountParam = [&](auto const& param) {
1026 json::Value params;
1027 params[jss::account] = alice.human();
1028 params[jss::destination_account] = param;
1029 auto const jrr =
1030 env.rpc("json", "account_channels", to_string(params))[jss::result];
1031 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
1032 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1033 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'destination_account'.");
1034 };
1035
1036 testInvalidDestAccountParam(1);
1037 testInvalidDestAccountParam(1.1);
1038 testInvalidDestAccountParam(true);
1039 testInvalidDestAccountParam(json::Value(json::ValueType::Null));
1040 testInvalidDestAccountParam(json::Value(json::ValueType::Object));
1041 testInvalidDestAccountParam(json::Value(json::ValueType::Array));
1042 }
1043 {
1044 // An empty destination_account is no destination at all.
1045 json::Value params;
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());
1052 }
1053 {
1054 // A malformed account is reported without the ledger fields.
1055 json::Value params;
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");
1059 BEAST_EXPECT(jrr[jss::error_code] == RpcActMalformed);
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));
1063 }
1064 {
1065 // A bad limit is reported before an account that is not found.
1066 json::Value params;
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");
1071 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
1072 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'limit'.");
1073 }
1074 {
1075 // A non-string marker names the field; one that does not parse does not.
1076 json::Value params;
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");
1082 BEAST_EXPECT(notString[jss::error_code] == RpcInvalidParams);
1083 BEAST_EXPECT(notString[jss::error_message] == "Invalid field 'marker', not string.");
1084
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");
1089 BEAST_EXPECT(malformed[jss::error_code] == RpcInvalidParams);
1090 BEAST_EXPECT(malformed[jss::error_message] == "Invalid parameters.");
1091 }
1092 {
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]);
1097 }
1098 {
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]);
1103 }
1104 {
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]);
1108 }
1109 auto const chan2Str = to_string(channel(alice, bob, env.seq(alice)));
1110 env(create(alice, bob, channelFunds, settleDelay, pk));
1111 env.close();
1112 {
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})
1118 {
1119 BEAST_EXPECT(
1120 r[jss::result][jss::channels][0u][jss::channel_id] == c ||
1121 r[jss::result][jss::channels][1u][jss::channel_id] == c);
1122 }
1123 }
1124 }
1125
1126 void
1128 {
1129 testcase("Account channels RPC markers");
1130
1131 using namespace test::jtx;
1132 using namespace std::literals;
1133
1134 auto const alice = Account("alice");
1135 auto const bobs = [] -> std::vector<Account> {
1136 int const n = 10;
1138 r.reserve(n);
1139 for (int i = 0; i < n; ++i)
1140 {
1141 r.emplace_back("bob"s + std::to_string(i));
1142 }
1143 return r;
1144 }();
1145
1146 Env env{*this, features};
1147 env.fund(XRP(10000), alice);
1148 for (auto const& a : bobs)
1149 {
1150 env.fund(XRP(10000), a);
1151 env.close();
1152 }
1153
1154 {
1155 // create a channel from alice to every bob account
1156 auto const settleDelay = 3600s;
1157 auto const channelFunds = XRP(1);
1158 for (auto const& b : bobs)
1159 {
1160 env(create(alice, b, channelFunds, settleDelay, alice.pk()));
1161 }
1162 }
1163
1164 auto testLimit = [](test::jtx::Env& env,
1165 test::jtx::Account const& src,
1166 std::optional<int> limit = std::nullopt,
1167 json::Value const& marker = json::ValueType::Null,
1168 std::optional<test::jtx::Account> const& dst = std::nullopt) {
1169 json::Value jvc;
1170 jvc[jss::account] = src.human();
1171 if (dst)
1172 jvc[jss::destination_account] = dst->human();
1173 if (limit)
1174 jvc[jss::limit] = *limit;
1175 if (marker)
1176 jvc[jss::marker] = marker;
1177
1178 return env.rpc("json", "account_channels", to_string(jvc))[jss::result];
1179 };
1180
1181 {
1182 // No marker
1183 auto const r = testLimit(env, alice);
1184 BEAST_EXPECT(r.isMember(jss::channels));
1185 BEAST_EXPECT(r[jss::channels].size() == bobs.size());
1186 }
1187
1188 auto const bobsB58 = [&bobs] -> std::set<std::string> {
1190 for (auto const& a : bobs)
1191 r.insert(a.human());
1192 return r;
1193 }();
1194
1195 for (int limit = 1; limit < bobs.size() + 1; ++limit)
1196 {
1197 auto leftToFind = bobsB58;
1198 auto const numFull = bobs.size() / limit;
1199 auto const numNonFull = ((bobs.size() % limit) != 0u) ? 1 : 0;
1200
1202
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)
1212 {
1213 auto const dstAcc = c[j][jss::destination_account].asString();
1214 BEAST_EXPECT(leftToFind.count(dstAcc));
1215 leftToFind.erase(dstAcc);
1216 }
1217 };
1218
1219 for (int i = 0; i < numFull; ++i)
1220 {
1221 bool const expectMarker = (numNonFull != 0 || i < numFull - 1);
1222 testIt(expectMarker, limit);
1223 }
1224
1225 if (numNonFull != 0)
1226 {
1227 testIt(false, bobs.size() % limit);
1228 }
1229 BEAST_EXPECT(leftToFind.empty());
1230 }
1231
1232 {
1233 // degenerate case
1234 auto const r = testLimit(env, alice, 0);
1235 BEAST_EXPECT(r[jss::error] == "invalidParams");
1236 BEAST_EXPECT(r[jss::error_code] == RpcInvalidParams);
1237 BEAST_EXPECT(r[jss::error_message] == "Invalid field 'limit'.");
1238 }
1239
1240 {
1241 // The marker's start hint may have a leading '+', and anything after a second
1242 // comma is ignored.
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);
1247
1248 auto const rest = testLimit(
1249 env,
1250 alice,
1251 std::nullopt,
1252 marker.substr(0, comma) + ",+" + marker.substr(comma + 1) + ",ignored");
1253 BEAST_EXPECT(rest[jss::channels].size() == bobs.size() - 1);
1254
1256 first[jss::channels][0u][jss::destination_account].asString(),
1257 };
1258
1259 for (auto const& c : rest[jss::channels])
1260 BEAST_EXPECT(found.insert(c[jss::destination_account].asString()).second);
1261
1262 BEAST_EXPECT(found == bobsB58);
1263 }
1264 }
1265
1266 void
1268 {
1269 // Check that the account_channels command only returns channels owned
1270 // by the account
1271 testcase("Account channels RPC owner only");
1272
1273 using namespace test::jtx;
1274 using namespace std::literals;
1275
1276 auto const alice = Account("alice");
1277 auto const bob = Account("bob");
1278 Env env{*this, features};
1279 env.fund(XRP(10000), alice, bob);
1280
1281 // Create a channel from alice to bob and from bob to alice
1282 // When retrieving alice's channels, it should only retrieve the
1283 // channels where alice is the source, not the destination
1284 auto const settleDelay = 3600s;
1285 auto const channelFunds = XRP(1000);
1286 env(create(alice, bob, channelFunds, settleDelay, alice.pk()));
1287 env(create(bob, alice, channelFunds, settleDelay, bob.pk()));
1288
1289 auto const r = [&] {
1290 json::Value jvc;
1291 jvc[jss::account] = alice.human();
1292
1293 return env.rpc("json", "account_channels", to_string(jvc))[jss::result];
1294 }();
1295 BEAST_EXPECT(r.isMember(jss::channels));
1296 BEAST_EXPECT(r[jss::channels].size() == 1);
1297 BEAST_EXPECT(r[jss::channels][0u][jss::destination_account].asString() == bob.human());
1298 }
1299
1300 void
1302 {
1303 using namespace jtx;
1304 using namespace std::literals::chrono_literals;
1305
1306 Env env{*this, features};
1307 auto const alice = Account("alice");
1308 auto const bob = Account("bob");
1309 auto const charlie = Account("charlie", KeyType::Ed25519);
1310 env.fund(XRP(10000), alice, bob, charlie);
1311 auto const pk = alice.pk();
1312 auto const settleDelay = 3600s;
1313 auto const channelFunds = XRP(1000);
1314 auto const chan1Str = to_string(channel(alice, bob, env.seq(alice)));
1315 env(create(alice, bob, channelFunds, settleDelay, pk));
1316 env.close();
1317
1319 args[jss::channel_id] = chan1Str;
1320 args[jss::key_type] = "ed255191";
1321 args[jss::seed] = "snHq1rzQoN2qiUkC3XF5RyxBzUtN";
1322 args[jss::amount] = 51110000;
1323
1324 // test for all api versions
1325 forAllApiVersions([&, this](unsigned apiVersion) {
1326 testcase("PayChan Channel_Auth RPC Api " + std::to_string(apiVersion));
1327 args[jss::api_version] = apiVersion;
1328 auto const rs =
1329 env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
1330 auto const error = apiVersion < 2u ? "invalidParams" : "badKeyType";
1331 auto const errorCode = apiVersion < 2u ? RpcInvalidParams : RpcBadKeyType;
1332 auto const errorMessage =
1333 apiVersion < 2u ? "Invalid field 'key_type'." : "Bad key type.";
1334 BEAST_EXPECT(rs[jss::error] == error);
1335 BEAST_EXPECT(rs[jss::error_code] == errorCode);
1336 BEAST_EXPECT(rs[jss::error_message] == errorMessage);
1337 });
1338 }
1339
1340 void
1342 {
1343 testcase("PayChan Auth/Verify RPC");
1344 using namespace jtx;
1345 using namespace std::literals::chrono_literals;
1346 Env env{*this, features};
1347 auto const alice = Account("alice");
1348 auto const bob = Account("bob");
1349 auto const charlie = Account("charlie", KeyType::Ed25519);
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);
1354 auto const chan1Str = to_string(channel(alice, bob, env.seq(alice)));
1355 env(create(alice, bob, channelFunds, settleDelay, pk));
1356 env.close();
1357 std::string chan1PkStr;
1358 {
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();
1364 }
1365 {
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();
1371 }
1372 {
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]);
1376 }
1377 auto const chan2Str = to_string(channel(alice, bob, env.seq(alice)));
1378 env(create(alice, bob, channelFunds, settleDelay, pk));
1379 env.close();
1380 {
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})
1386 {
1387 BEAST_EXPECT(
1388 r[jss::result][jss::channels][0u][jss::channel_id] == c ||
1389 r[jss::result][jss::channels][1u][jss::channel_id] == c);
1390 }
1391 }
1392
1393 auto const sliceToHex = [](Slice const& slice) {
1394 std::string s;
1395 s.reserve(2 * slice.size());
1396 for (std::uint8_t const byte : slice)
1397 {
1398 s += "0123456789ABCDEF"[((byte & 0xf0) >> 4)];
1399 s += "0123456789ABCDEF"[((byte & 0x0f) >> 0)];
1400 }
1401 return s;
1402 };
1403
1404 {
1405 // Verify chan1 auth
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());
1409 {
1410 auto const rv = env.rpc("channel_verify", chan1PkStr, chan1Str, "1000", sig);
1411 BEAST_EXPECT(rv[jss::result][jss::signature_verified].asBool());
1412 }
1413
1414 {
1415 // use pk hex to verify
1416 auto const pkAsHex = sliceToHex(pk.slice());
1417 auto const rv = env.rpc("channel_verify", pkAsHex, chan1Str, "1000", sig);
1418 BEAST_EXPECT(rv[jss::result][jss::signature_verified].asBool());
1419 }
1420 {
1421 // malformed amount
1422 auto const pkAsHex = sliceToHex(pk.slice());
1423 auto rv = env.rpc("channel_verify", pkAsHex, chan1Str, "1000x", sig);
1424 BEAST_EXPECT(rv[jss::error] == "channelAmtMalformed");
1425 BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
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");
1429 BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
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");
1433 BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
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");
1437 BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
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");
1441 BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
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");
1445 BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
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");
1449 BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
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");
1453 BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
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");
1457 BEAST_EXPECT(rv[jss::error_code] == RpcChannelAmtMalformed);
1458 BEAST_EXPECT(rv[jss::error_message] == "Payment channel amount is malformed.");
1459 }
1460 {
1461 // malformed channel
1462 auto const pkAsHex = sliceToHex(pk.slice());
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");
1467 BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
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");
1471 BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
1472 BEAST_EXPECT(rv[jss::error_message] == "Payment channel is malformed.");
1473
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");
1478 BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
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");
1482 BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
1483 BEAST_EXPECT(rv[jss::error_message] == "Payment channel is malformed.");
1484
1485 chan1StrBad = chan1Str;
1486 chan1StrBad.back() = 'x';
1487 rv = env.rpc("channel_verify", pkAsHex, chan1StrBad, "1000", sig);
1488 BEAST_EXPECT(rv[jss::error] == "channelMalformed");
1489 BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
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");
1493 BEAST_EXPECT(rv[jss::error_code] == RpcChannelMalformed);
1494 BEAST_EXPECT(rv[jss::error_message] == "Payment channel is malformed.");
1495 }
1496 {
1497 // channel_id is not a string.
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";
1503
1504 auto const ra =
1505 env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
1506 BEAST_EXPECT(ra[jss::error] == "invalidParams");
1507 BEAST_EXPECT(ra[jss::error_code] == RpcInvalidParams);
1508 BEAST_EXPECT(ra[jss::error_message] == "Invalid parameters.");
1509 }
1510 {
1511 // channel_id is not a string.
1513 args[jss::public_key] = chan1PkStr;
1514 args[jss::channel_id] = 2000;
1515 args[jss::amount] = "1000";
1516 args[jss::signature] = sig;
1517
1518 auto const rv =
1519 env.rpc("json", "channel_verify", args.toStyledString())[jss::result];
1520 BEAST_EXPECT(rv[jss::error] == "invalidParams");
1521 BEAST_EXPECT(rv[jss::error_code] == RpcInvalidParams);
1522 BEAST_EXPECT(rv[jss::error_message] == "Invalid parameters.");
1523 }
1524 {
1525 // give an ill formed base 58 public key
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());
1529 }
1530 {
1531 // give an ill formed hex public key
1532 auto const pkAsHex = sliceToHex(pk.slice());
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());
1536 }
1537 }
1538 {
1539 // Try to verify chan2 auth with chan1 key
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());
1543 {
1544 auto const rv = env.rpc("channel_verify", chan1PkStr, chan1Str, "1000", sig);
1545 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1546 }
1547 {
1548 // use pk hex to verify
1549 auto const pkAsHex = sliceToHex(pk.slice());
1550 auto const rv = env.rpc("channel_verify", pkAsHex, chan1Str, "1000", sig);
1551 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1552 }
1553 }
1554 {
1555 // Try to explicitly specify secp256k1 and Ed25519 keys:
1556 auto const chan = to_string(channel(charlie, alice, env.seq(charlie)));
1557 env(create(charlie, alice, channelFunds, settleDelay, charlie.pk()));
1558 env.close();
1559
1560 std::string cpk;
1561 {
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();
1567 }
1568
1569 // Try to authorize without specifying a key type, expect an error:
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());
1573 {
1574 auto const rv = env.rpc("channel_verify", cpk, chan, "1000", sig);
1575 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1576 }
1577
1578 // Try to authorize using an unknown key type, except an error:
1579 auto const rs1 = env.rpc("channel_authorize", "charlie", "nyx", chan, "1000");
1580 BEAST_EXPECT(rs1[jss::error] == "badKeyType");
1581 BEAST_EXPECT(rs1[jss::error_code] == RpcBadKeyType);
1582 BEAST_EXPECT(rs1[jss::error_message] == "Bad key type.");
1583
1584 // Try to authorize using secp256k1; the authorization _should_
1585 // succeed but the verification should fail:
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());
1589 {
1590 auto const rv = env.rpc("channel_verify", cpk, chan, "1000", sig2);
1591 BEAST_EXPECT(!rv[jss::result][jss::signature_verified].asBool());
1592 }
1593
1594 // Try to authorize using Ed25519; expect success:
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());
1598 {
1599 auto const rv = env.rpc("channel_verify", cpk, chan, "1000", sig3);
1600 BEAST_EXPECT(rv[jss::result][jss::signature_verified].asBool());
1601 }
1602 }
1603
1604 {
1605 // send malformed amounts rpc requests
1606 auto rs = env.rpc("channel_authorize", "alice", chan1Str, "1000x");
1607 BEAST_EXPECT(rs[jss::error] == "channelAmtMalformed");
1608 BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
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");
1612 BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
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");
1616 BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
1617 BEAST_EXPECT(rs[jss::error_message] == "Payment channel amount is malformed.");
1618 {
1619 // Missing channel_id
1621 args[jss::amount] = "2000";
1622 args[jss::key_type] = "secp256k1";
1623 args[jss::passphrase] = "passphrase_can_be_anything";
1624 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
1625 BEAST_EXPECT(rs[jss::error] == "invalidParams");
1626 BEAST_EXPECT(rs[jss::error_code] == RpcInvalidParams);
1627 BEAST_EXPECT(rs[jss::error_message] == "Missing field 'channel_id'.");
1628 }
1629 {
1630 // Missing amount
1632 args[jss::channel_id] = chan1Str;
1633 args[jss::key_type] = "secp256k1";
1634 args[jss::passphrase] = "passphrase_can_be_anything";
1635 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
1636 BEAST_EXPECT(rs[jss::error] == "invalidParams");
1637 BEAST_EXPECT(rs[jss::error_code] == RpcInvalidParams);
1638 BEAST_EXPECT(rs[jss::error_message] == "Missing field 'amount'.");
1639 }
1640 {
1641 // Missing key_type and no secret.
1643 args[jss::amount] = "2000";
1644 args[jss::channel_id] = chan1Str;
1645 args[jss::passphrase] = "passphrase_can_be_anything";
1646 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
1647 BEAST_EXPECT(rs[jss::error] == "invalidParams");
1648 BEAST_EXPECT(rs[jss::error_code] == RpcInvalidParams);
1649 BEAST_EXPECT(rs[jss::error_message] == "Missing field 'secret'.");
1650 }
1651 {
1652 // Both passphrase and seed specified.
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";
1659 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
1660 BEAST_EXPECT(rs[jss::error] == "invalidParams");
1661 BEAST_EXPECT(rs[jss::error_code] == RpcInvalidParams);
1662 BEAST_EXPECT(
1663 rs[jss::error_message] ==
1664 "Exactly one of the following must be specified: passphrase, secret, seed or "
1665 "seed_hex");
1666 }
1667 {
1668 // channel_id is not exact hex.
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";
1674 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
1675 BEAST_EXPECT(rs[jss::error] == "channelMalformed");
1676 BEAST_EXPECT(rs[jss::error_code] == RpcChannelMalformed);
1677 BEAST_EXPECT(rs[jss::error_message] == "Payment channel is malformed.");
1678 }
1679 {
1680 // amount is not a string
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";
1686 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
1687 BEAST_EXPECT(rs[jss::error] == "channelAmtMalformed");
1688 BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
1689 BEAST_EXPECT(rs[jss::error_message] == "Payment channel amount is malformed.");
1690 }
1691 {
1692 // Amount is not a decimal string.
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";
1698 rs = env.rpc("json", "channel_authorize", args.toStyledString())[jss::result];
1699 BEAST_EXPECT(rs[jss::error] == "channelAmtMalformed");
1700 BEAST_EXPECT(rs[jss::error_code] == RpcChannelAmtMalformed);
1701 BEAST_EXPECT(rs[jss::error_message] == "Payment channel amount is malformed.");
1702 }
1703 }
1704 }
1705
1706 void
1708 {
1709 testcase("Optional Fields");
1710 using namespace jtx;
1711 using namespace std::literals::chrono_literals;
1712 Env env{*this, features};
1713 auto const alice = Account("alice");
1714 auto const bob = Account("bob");
1715 auto const carol = Account("carol");
1716 auto const dan = Account("dan");
1717 env.fund(XRP(10000), alice, bob, carol, dan);
1718 auto const pk = alice.pk();
1719 auto const settleDelay = 3600s;
1720 auto const channelFunds = XRP(1000);
1721
1722 std::optional<NetClock::time_point> const cancelAfter;
1723
1724 {
1725 auto const chan = to_string(channel(alice, bob, env.seq(alice)));
1726 env(create(alice, bob, channelFunds, settleDelay, pk));
1727 auto const r = env.rpc("account_channels", alice.human(), bob.human());
1728 BEAST_EXPECT(r[jss::result][jss::channels].size() == 1);
1729 BEAST_EXPECT(r[jss::result][jss::channels][0u][jss::channel_id] == chan);
1730 BEAST_EXPECT(!r[jss::result][jss::channels][0u].isMember(jss::destination_tag));
1731 }
1732 {
1733 std::uint32_t dstTag = 42;
1734 auto const chan = to_string(channel(alice, carol, env.seq(alice)));
1735 env(create(alice, carol, channelFunds, settleDelay, pk, cancelAfter, dstTag));
1736 auto const r = env.rpc("account_channels", alice.human(), carol.human());
1737 BEAST_EXPECT(r[jss::result][jss::channels].size() == 1);
1738 BEAST_EXPECT(r[jss::result][jss::channels][0u][jss::channel_id] == chan);
1739 BEAST_EXPECT(r[jss::result][jss::channels][0u][jss::destination_tag] == dstTag);
1740 }
1741 }
1742
1743 void
1745 {
1746 testcase("channel_verify sets kFEE_HEAVY_BURDEN_RPC load type");
1747
1748 using namespace jtx;
1749 using namespace std::literals::chrono_literals;
1750
1751 Env env{*this, features};
1752 auto const alice = Account("alice");
1753 auto const bob = Account("bob");
1754
1755 env.fund(XRP(10000), alice, bob);
1756
1757 auto const pk = alice.pk();
1758 auto const settleDelay = 3600s;
1759 auto const channelFunds = XRP(1000);
1760 auto const chanStr = to_string(channel(alice, bob, env.seq(alice)));
1761
1762 env(create(alice, bob, channelFunds, settleDelay, pk));
1763 env.close();
1764
1765 // Step 1: get a valid signature from channel_authorize
1766 auto const authResult = env.rpc("channel_authorize", "alice", chanStr, "1000");
1767 auto const sig = authResult[jss::result][jss::signature].asString();
1768 BEAST_EXPECT(!sig.empty());
1769 auto const pkHex = strHex(pk.slice());
1770
1771 // Step 2: build rpc::JsonContext directly so we can inspect loadType
1772 auto& app = env.app();
1775 rpc::JsonContext context{
1776 {
1777 .j = env.journal,
1778 .app = app,
1779 .loadType = loadType,
1780 .netOps = app.getOPs(),
1781 .ledgerMaster = app.getLedgerMaster(),
1782 .consumer = c,
1783 .role = Role::USER,
1784 .coro = {},
1785 .infoSub = {},
1786 .apiVersion = rpc::kApiVersionIfUnspecified,
1787 },
1788 {},
1789 // NOLINTNEXTLINE(readability-trailing-comma) fix-it drops comma after `{}`
1790 {},
1791 };
1792 json::Value params;
1793 params[jss::public_key] = pkHex;
1794 params[jss::channel_id] = chanStr;
1795 params[jss::amount] = "1000";
1796 params[jss::signature] = sig;
1797 context.params = std::move(params);
1798
1799 // Confirm default before calling handler
1800 BEAST_EXPECT(context.loadType == resource::kFeeReferenceRpc);
1801 json::Value result;
1802 Gate g;
1803 app.getJobQueue().postCoro(JtClient, "RPC-Client", [&](auto const& coro) {
1804 context.coro = coro;
1805 result = doChannelVerify(context);
1806 g.signal();
1807 });
1808
1809 using namespace std::chrono_literals;
1810 BEAST_EXPECT(g.waitFor(5s));
1811 // Signature must verify correctly
1812 BEAST_EXPECT(result[jss::signature_verified].asBool());
1813 // KEY ASSERTION: loadType must be kFEE_HEAVY_BURDEN_RPC after the fix
1814 // Before fix: this will FAIL because loadType stays kFEE_REFERENCE_RPC (20)
1815 // After fix: this will PASS because loadType is kFEE_HEAVY_BURDEN_RPC (3000)
1816 BEAST_EXPECT(context.loadType == resource::kFeeHeavyBurdenRpc);
1817 // Confirm the charge is 150x heavier than the current (broken) default
1818 BEAST_EXPECT(context.loadType.cost() == resource::kFeeHeavyBurdenRpc.cost()); // 3000
1819 BEAST_EXPECT(context.loadType.cost() != resource::kFeeReferenceRpc.cost()); // not 20
1820 }
1821
1822 void
1824 {
1825 testcase("channel_authorize sets kFEE_HEAVY_BURDEN_RPC load type");
1826
1827 using namespace jtx;
1828 using namespace std::literals::chrono_literals;
1829
1830 Env env{*this, features};
1831 auto const alice = Account("alice");
1832 auto const bob = Account("bob");
1833
1834 env.fund(XRP(10000), alice, bob);
1835
1836 auto const pk = alice.pk();
1837 auto const settleDelay = 3600s;
1838 auto const chanStr = to_string(channel(alice, bob, env.seq(alice)));
1839
1840 env(create(alice, bob, XRP(1000), settleDelay, pk));
1841 env.close();
1842
1843 auto& app = env.app();
1846 rpc::JsonContext context{
1847 {
1848 .j = env.journal,
1849 .app = app,
1850 .loadType = loadType,
1851 .netOps = app.getOPs(),
1852 .ledgerMaster = app.getLedgerMaster(),
1853 .consumer = c,
1854 .role = Role::ADMIN, // channel_authorize requires ADMIN or canSign()
1855 .coro = {},
1856 .infoSub = {},
1857 .apiVersion = rpc::kApiVersionIfUnspecified,
1858 },
1859 {},
1860 // NOLINTNEXTLINE(readability-trailing-comma) fix-it drops comma after `{}`
1861 {},
1862 };
1863 json::Value params;
1864 params[jss::channel_id] = chanStr;
1865 params[jss::amount] = "1000";
1866 params[jss::secret] = alice.name(); // use account name as seed
1867 context.params = std::move(params);
1868
1869 // Confirm default before calling handler
1870 BEAST_EXPECT(context.loadType == resource::kFeeReferenceRpc);
1871 json::Value result;
1872 Gate g;
1873 app.getJobQueue().postCoro(JtClient, "RPC-Client", [&](auto const& coro) {
1874 context.coro = coro;
1875 result = doChannelAuthorize(context);
1876 g.signal();
1877 });
1878
1879 using namespace std::chrono_literals;
1880
1881 BEAST_EXPECT(g.waitFor(5s));
1882 // Must return a valid signature
1883 BEAST_EXPECT(result.isMember(jss::signature));
1884 BEAST_EXPECT(!result[jss::signature].asString().empty());
1885 // KEY ASSERTION: loadType must be kFEE_HEAVY_BURDEN_RPC after the fix
1886 // Before fix: FAILS — stays at kFEE_REFERENCE_RPC (charge=20)
1887 // After fix: PASSES — set to kFEE_HEAVY_BURDEN_RPC (charge=3000)
1888 BEAST_EXPECT(context.loadType == resource::kFeeHeavyBurdenRpc);
1889 }
1890
1891 void
1893 {
1894 testcase("malformed pk");
1895 using namespace jtx;
1896 using namespace std::literals::chrono_literals;
1897 Env env{*this, features};
1898 auto const alice = Account("alice");
1899 auto const bob = Account("bob");
1900 auto const usda = alice["USD"];
1901 env.fund(XRP(10000), alice, bob);
1902 auto const pk = alice.pk();
1903 auto const settleDelay = 100s;
1904
1905 auto const chan = channel(alice, bob, env.seq(alice));
1906 auto jv = create(alice, bob, XRP(1000), settleDelay, pk);
1907 auto const pkHex = strHex(pk.slice());
1908 jv["PublicKey"] = pkHex.substr(2, pkHex.size() - 2);
1909 env(jv, Ter(temMALFORMED));
1910 jv["PublicKey"] = pkHex.substr(0, pkHex.size() - 2);
1911 env(jv, Ter(temMALFORMED));
1912 auto badPrefix = pkHex;
1913 badPrefix[0] = 'f';
1914 badPrefix[1] = 'f';
1915 jv["PublicKey"] = badPrefix;
1916 env(jv, Ter(temMALFORMED));
1917
1918 jv["PublicKey"] = pkHex;
1919 env(jv);
1920
1921 auto const authAmt = XRP(100);
1922 auto const sig = signClaimAuth(alice.pk(), alice.sk(), chan, authAmt);
1923 jv = claim(bob, chan, authAmt.value(), authAmt.value(), Slice(sig), alice.pk());
1924 jv["PublicKey"] = pkHex.substr(2, pkHex.size() - 2);
1925 env(jv, Ter(temMALFORMED));
1926 jv["PublicKey"] = pkHex.substr(0, pkHex.size() - 2);
1927 env(jv, Ter(temMALFORMED));
1928 badPrefix = pkHex;
1929 badPrefix[0] = 'f';
1930 badPrefix[1] = 'f';
1931 jv["PublicKey"] = badPrefix;
1932 env(jv, Ter(temMALFORMED));
1933
1934 // missing public key
1935 jv.removeMember("PublicKey");
1936 env(jv, Ter(temMALFORMED));
1937
1938 {
1939 auto const txn = R"*(
1940 {
1941
1942 "channel_id":"5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3",
1943 "signature":
1944 "304402204EF0AFB78AC23ED1C472E74F4299C0C21F1B21D07EFC0A3838A420F76D783A400220154FB11B6F54320666E4C36CA7F686C16A3A0456800BBC43746F34AF50290064",
1945 "public_key":
1946 "aKijDDiC2q2gXjMpM7i4BUS6cmixgsEe18e7CjsUxwihKfuoFgS5",
1947 "amount": "1000000"
1949 )*";
1950 auto const r = env.rpc("json", "channel_verify", txn);
1951 BEAST_EXPECT(r["result"]["error"] == "publicMalformed");
1952 BEAST_EXPECT(r["result"]["error_code"] == RpcPublicMalformed);
1953 BEAST_EXPECT(r["result"]["error_message"] == "Public key is malformed.");
1954 }
1955 }
1956
1957 void
1959 {
1960 testcase("Metadata & Ownership");
1961
1962 using namespace jtx;
1963 using namespace std::literals::chrono_literals;
1964
1965 auto const alice = Account("alice");
1966 auto const bob = Account("bob");
1967 auto const settleDelay = 100s;
1968 auto const pk = alice.pk();
1969
1970 auto const inOwnerDir =
1971 [](ReadView const& view, Account const& acc, SLE::ConstRef chan) -> bool {
1972 auto const ownerDir = ownerDirEntries(view, acc);
1973 // NOLINTNEXTLINE(modernize-use-ranges)
1974 return std::find(ownerDir.begin(), ownerDir.end(), chan) != ownerDir.end();
1975 };
1976
1977 auto const ownerDirCount = [](ReadView const& view, Account const& acc) -> std::size_t {
1978 auto const ownerDir = ownerDirEntries(view, acc);
1979 return std::distance(ownerDir.begin(), ownerDir.end());
1980 };
1981
1982 {
1983 // Test with adding the paychan to the recipient's owner directory
1984 Env env{*this, features};
1985 env.fund(XRP(10000), alice, bob);
1986 env(create(alice, bob, XRP(1000), settleDelay, pk));
1987 env.close();
1988 auto const [chan, chanSle] = channelKeyAndSle(*env.current(), alice, bob);
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);
1993 // close the channel
1994 env(claim(bob, chan), Txflags(tfClose));
1995 BEAST_EXPECT(!channelExists(*env.current(), chan));
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);
2000 }
2001
2002 {
2003 // Test removing paychans created before adding to the recipient's
2004 // owner directory
2005 Env env(*this, features);
2006 env.fund(XRP(10000), alice, bob);
2007 // create the channel before the amendment activates
2008 env(create(alice, bob, XRP(1000), settleDelay, pk));
2009 env.close();
2010 auto const [chan, chanSle] = channelKeyAndSle(*env.current(), alice, bob);
2011 BEAST_EXPECT(inOwnerDir(*env.current(), alice, chanSle));
2012 BEAST_EXPECT(ownerDirCount(*env.current(), alice) == 1);
2013 BEAST_EXPECT(inOwnerDir(*env.current(), bob, chanSle));
2014 BEAST_EXPECT(ownerDirCount(*env.current(), bob) == 1);
2015
2016 env(claim(bob, chan), Txflags(tfClose));
2017 BEAST_EXPECT(!channelExists(*env.current(), chan));
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);
2022 }
2023 }
2024
2025 void
2027 {
2028 testcase("Account Delete");
2029 using namespace test::jtx;
2030 using namespace std::literals::chrono_literals;
2031 auto const rmAccount =
2032 [this](
2033 Env& env, Account const& toRm, Account const& dst, TER expectedTer = tesSUCCESS) {
2034 // only allow an account to be deleted if the account's sequence
2035 // number is at least 256 less than the current ledger sequence
2036 for (auto minRmSeq = env.seq(toRm) + 257; env.current()->seq() < minRmSeq;
2037 env.close())
2038 {
2039 }
2040
2041 env(acctdelete(toRm, dst),
2042 Fee(drops(env.current()->fees().increment)),
2043 Ter(expectedTer));
2044 env.close();
2045 this->BEAST_EXPECT(
2046 isTesSuccess(expectedTer) == !env.closed()->exists(keylet::account(toRm.id())));
2047 };
2048
2049 auto const alice = Account("alice");
2050 auto const bob = Account("bob");
2051 auto const carol = Account("carol");
2052
2053 {
2054 Env env{*this, features};
2055 env.fund(XRP(10000), alice, bob, carol);
2056 env.close();
2057
2058 // Create a channel from alice to bob
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));
2063 env.close();
2064 BEAST_EXPECT(channelBalance(*env.current(), chan) == XRP(0));
2065 BEAST_EXPECT(channelAmount(*env.current(), chan) == XRP(1000));
2066
2067 rmAccount(env, alice, carol, tecHAS_OBLIGATIONS);
2068 rmAccount(env, bob, carol, TER(tecHAS_OBLIGATIONS));
2069
2070 auto const feeDrops = env.current()->fees().base;
2071 auto chanBal = channelBalance(*env.current(), chan);
2072 auto chanAmt = channelAmount(*env.current(), chan);
2073 BEAST_EXPECT(chanBal == XRP(0));
2074 BEAST_EXPECT(chanAmt == XRP(1000));
2075
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);
2081
2082 env(claim(alice, chan, reqBal, authAmt));
2083 env.close();
2084 BEAST_EXPECT(channelBalance(*env.current(), chan) == reqBal);
2085 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
2086 BEAST_EXPECT(env.balance(bob) == preBob + delta);
2087 chanBal = reqBal;
2088
2089 auto const preAlice = env.balance(alice);
2090 env(fund(alice, chan, XRP(1000)));
2091 env.close();
2092 BEAST_EXPECT(env.balance(alice) == preAlice - XRP(1000) - feeDrops);
2093 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt + XRP(1000));
2094 chanAmt = chanAmt + XRP(1000);
2095
2096 {
2097 // Owner closes, will close after settleDelay
2098 env(claim(alice, chan), Txflags(tfClose));
2099 env.close();
2100 // settle delay hasn't elapsed. Channels should exist.
2101 BEAST_EXPECT(channelExists(*env.current(), chan));
2102 auto const closeTime = env.current()->header().parentCloseTime;
2103 auto const minExpiration = closeTime + settleDelay;
2104 env.close(minExpiration);
2105 env(claim(alice, chan), Txflags(tfClose));
2106 BEAST_EXPECT(!channelExists(*env.current(), chan));
2107 }
2108 }
2109 }
2110
2111 void
2112 testUsingTickets(FeatureBitset features)
2113 {
2114 testcase("using tickets");
2115 using namespace jtx;
2116 using namespace std::literals::chrono_literals;
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);
2122
2123 // alice and bob grab enough tickets for all of the following
2124 // transactions. Note that once the tickets are acquired alice's
2125 // and bob's account sequence numbers should not advance.
2126 std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
2127 env(ticket::create(alice, 10));
2128 std::uint32_t const aliceSeq{env.seq(alice)};
2129
2130 std::uint32_t bobTicketSeq{env.seq(bob) + 1};
2131 env(ticket::create(bob, 10));
2132 std::uint32_t const bobSeq{env.seq(bob)};
2133
2134 auto const pk = alice.pk();
2135 auto const settleDelay = 100s;
2136 auto const chan = channel(alice, bob, aliceTicketSeq);
2137
2138 env(create(alice, bob, XRP(1000), settleDelay, pk), ticket::Use(aliceTicketSeq++));
2139
2140 env.require(Tickets(alice, env.seq(alice) - aliceTicketSeq));
2141 BEAST_EXPECT(env.seq(alice) == aliceSeq);
2142
2143 BEAST_EXPECT(channelBalance(*env.current(), chan) == XRP(0));
2144 BEAST_EXPECT(channelAmount(*env.current(), chan) == XRP(1000));
2145
2146 {
2147 auto const preAlice = env.balance(alice);
2148 env(fund(alice, chan, XRP(1000)), ticket::Use(aliceTicketSeq++));
2149
2150 env.require(Tickets(alice, env.seq(alice) - aliceTicketSeq));
2151 BEAST_EXPECT(env.seq(alice) == aliceSeq);
2152
2153 auto const feeDrops = env.current()->fees().base;
2154 BEAST_EXPECT(env.balance(alice) == preAlice - XRP(1000) - feeDrops);
2155 }
2156
2157 auto chanBal = channelBalance(*env.current(), chan);
2158 auto const chanAmt = channelAmount(*env.current(), chan);
2159 BEAST_EXPECT(chanBal == XRP(0));
2160 BEAST_EXPECT(chanAmt == XRP(2000));
2161
2162 {
2163 // No signature needed since the owner is claiming
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++));
2170
2171 env.require(Tickets(alice, env.seq(alice) - aliceTicketSeq));
2172 BEAST_EXPECT(env.seq(alice) == aliceSeq);
2173
2174 BEAST_EXPECT(channelBalance(*env.current(), chan) == reqBal);
2175 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
2176 BEAST_EXPECT(env.balance(bob) == preBob + delta);
2177 chanBal = reqBal;
2178 }
2179 {
2180 // Claim with signature
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++));
2189
2190 env.require(Tickets(bob, env.seq(bob) - bobTicketSeq));
2191 BEAST_EXPECT(env.seq(bob) == bobSeq);
2192
2193 BEAST_EXPECT(channelBalance(*env.current(), chan) == reqBal);
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);
2197 chanBal = reqBal;
2198
2199 // claim again
2200 preBob = env.balance(bob);
2201 // A transaction that generates a tec still consumes its ticket.
2202 env(claim(bob, chan, reqBal, authAmt, Slice(sig), alice.pk()),
2203 ticket::Use(bobTicketSeq++),
2204 Ter(tecUNFUNDED_PAYMENT));
2205
2206 env.require(Tickets(bob, env.seq(bob) - bobTicketSeq));
2207 BEAST_EXPECT(env.seq(bob) == bobSeq);
2208
2209 BEAST_EXPECT(channelBalance(*env.current(), chan) == chanBal);
2210 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
2211 BEAST_EXPECT(env.balance(bob) == preBob - feeDrops);
2212 }
2213 {
2214 // Try to claim more than authorized
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);
2219 // Note that since claim() returns a tem (neither tec nor tes),
2220 // the ticket is not consumed. So we don't kIncrement bobTicket.
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),
2224 Ter(temBAD_AMOUNT));
2225
2226 env.require(Tickets(bob, env.seq(bob) - bobTicketSeq));
2227 BEAST_EXPECT(env.seq(bob) == bobSeq);
2228
2229 BEAST_EXPECT(channelBalance(*env.current(), chan) == chanBal);
2230 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
2231 BEAST_EXPECT(env.balance(bob) == preBob);
2232 }
2233
2234 // Dst tries to fund the channel
2235 env(fund(bob, chan, XRP(1000)), ticket::Use(bobTicketSeq++), Ter(tecNO_PERMISSION));
2236
2237 env.require(Tickets(bob, env.seq(bob) - bobTicketSeq));
2238 BEAST_EXPECT(env.seq(bob) == bobSeq);
2239
2240 BEAST_EXPECT(channelBalance(*env.current(), chan) == chanBal);
2241 BEAST_EXPECT(channelAmount(*env.current(), chan) == chanAmt);
2242
2243 {
2244 // Dst closes channel
2245 auto const preAlice = env.balance(alice);
2246 auto const preBob = env.balance(bob);
2247 env(claim(bob, chan), Txflags(tfClose), ticket::Use(bobTicketSeq++));
2248
2249 env.require(Tickets(bob, env.seq(bob) - bobTicketSeq));
2250 BEAST_EXPECT(env.seq(bob) == bobSeq);
2251
2252 BEAST_EXPECT(!channelExists(*env.current(), chan));
2253 auto const feeDrops = env.current()->fees().base;
2254 auto const delta = chanAmt - chanBal;
2255 assert(delta > beast::kZero);
2256 BEAST_EXPECT(env.balance(alice) == preAlice + delta);
2257 BEAST_EXPECT(env.balance(bob) == preBob - feeDrops);
2258 }
2259 env.require(Tickets(alice, env.seq(alice) - aliceTicketSeq));
2260 BEAST_EXPECT(env.seq(alice) == aliceSeq);
2261 env.require(Tickets(bob, env.seq(bob) - bobTicketSeq));
2262 BEAST_EXPECT(env.seq(bob) == bobSeq);
2263 }
2264
2265 void
2267 {
2268 testSimple(features);
2269 testDisallowIncoming(features);
2270 testCancelAfter(features);
2271 testSettleDelay(features);
2272 testExpiration(features);
2273 testCloseDry(features);
2274 testDefaultAmount(features);
2275 testDisallowXRP(features);
2276 testDstTag(features);
2277 testDepositAuth(features);
2278 testMultiple(features);
2279 testAccountChannelsRPC(features);
2283 testAuthVerifyRPC(features);
2284 testOptionalFields(features);
2286 testMetaAndOwnership(features);
2287 testAccountDelete(features);
2288 testUsingTickets(features);
2289 testChannelVerifyLoadType(features);
2291 }
2292
2293public:
2294 void
2295 run() override
2296 {
2297 using namespace test::jtx;
2298 // fixCleanup3_2_0 changes payment-channel error codes (tem* -> tec*)
2299 // and channel-closing semantics. This suite asserts the
2300 // pre-amendment behavior, so run it with the amendment disabled.
2301 FeatureBitset const all{testableAmendments() - fixCleanup3_2_0};
2302 testWithFeats(all);
2304 testMetaAndOwnership(all - fixIncludeKeyletFields);
2305 }
2306};
2307
2309} // namespace xrpl::test
A testsuite class.
Definition suite.h:52
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Represents a JSON value.
Definition json_value.h:121
std::string toStyledString() const
std::string asString() const
Returns the unquoted string value.
bool isMember(char const *key) const
Return true if the object has a member named key.
std::chrono::time_point< NetClock > time_point
Definition chrono.h:48
A view into a ledger.
Definition ReadView.h:41
virtual SLE::const_pointer read(Keylet const &k) const =0
Return the state item associated with a key.
std::shared_ptr< STLedgerEntry const > const & ConstRef
static constexpr SeqProxy rawSequence(std::uint32_t v)
Factory function to return a sequence-based SeqProxy.
Definition SeqProxy.h:62
An immutable linear range of bytes.
Definition Slice.h:28
A consumption charge.
Definition Charge.h:13
value_type cost() const
Return the cost of the charge in resource::Manager units.
Definition Charge.cpp:22
An endpoint that consumes resources.
Definition Consumer.h:20
Immutable cryptographic account descriptor.
Definition jtx/Account.h:21
PublicKey const & pk() const
Return the public key.
Definition jtx/Account.h:84
A transaction testing environment.
Definition Env.h:161
Application & app()
Definition Env.h:300
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition Env.cpp:133
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition Env.cpp:323
std::uint32_t seq(Account const &account) const
Returns the next sequence number on account.
Definition Env.cpp:302
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
Definition Env.h:1058
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
Definition Env.cpp:201
beast::Journal const journal
Definition Env.h:204
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
bool waitFor(std::chrono::duration< Rep, Period > const &relTime)
Set the expected result code for a JTx The test will fail if the code doesn't match.
Definition ter.h:18
Set the flags on a JTx.
Definition txflags.h:14
T distance(T... args)
T emplace_back(T... args)
T empty(T... args)
T find(T... args)
T insert(T... args)
constexpr Zero kZero
Definition Zero.h:30
@ 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 payChannel(AccountID const &src, AccountID const &dst, SeqProxy const &seq) noexcept
A PaymentChannel.
Definition Indexes.cpp:436
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition Indexes.cpp:233
Charge const kFeeHeavyBurdenRpc
Charge const kFeeReferenceRpc
static constexpr auto kApiVersionIfUnspecified
Definition ApiVersion.h:34
json::Value accept(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:29
json::Value create(jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:16
json::Value ledgerEntry(jtx::Env &env, jtx::Account const &subject, jtx::Account const &issuer, std::string_view credType)
Definition creds.cpp:56
json::Value authCredentials(jtx::Account const &account, std::vector< AuthorizeCredentials > const &auth)
Definition deposit.cpp:38
json::Value auth(Account const &account, Account const &auth)
Preauthorize for deposit.
Definition deposit.cpp:16
json::Value unauth(Account const &account, Account const &unauth)
Remove pre-authorization for deposit.
Definition deposit.cpp:27
Paychan operations.
Definition paychan.cpp:28
STAmount channelBalance(ReadView const &view, uint256 const &chan)
Definition paychan.cpp:104
json::Value create(AccountID const &account, AccountID const &to, STAmount const &amount, NetClock::duration const &settleDelay, PublicKey const &pk, std::optional< NetClock::time_point > const &cancelAfter, std::optional< std::uint32_t > const &dstTag)
Definition paychan.cpp:31
uint256 channel(AccountID const &account, AccountID const &dst, std::uint32_t seqProxyValue)
Definition paychan.cpp:96
json::Value claim(AccountID const &account, uint256 const &channel, std::optional< STAmount > const &balance, std::optional< STAmount > const &amount, std::optional< Slice > const &signature, std::optional< PublicKey > const &pk)
Definition paychan.cpp:72
STAmount channelAmount(ReadView const &view, uint256 const &chan)
Definition paychan.cpp:113
bool channelExists(ReadView const &view, uint256 const &chan)
Definition paychan.cpp:122
Buffer signClaimAuth(PublicKey const &pk, SecretKey const &sk, uint256 const &channel, STAmount const &authAmt)
Definition paychan.cpp:129
json::Value create(Account const &account, std::uint32_t count)
Create one of more tickets.
Definition ticket.cpp:16
std::vector< STAmount > fund(jtx::Env &env, jtx::Account const &gw, std::vector< jtx::Account > const &accounts, std::vector< STAmount > const &amts, Fund how)
Definition AMMTest.cpp:34
XrpT const XRP
Converts to XRP Issue or STAmount.
Definition amount.cpp:92
json::Value fclear(Account const &account, std::uint32_t off)
Remove account flag.
Definition flags.h:110
FeatureBitset testableAmendments()
Definition Env.h:92
json::Value acctdelete(Account const &account, Account const &dest)
Delete account.
std::vector< SLE::const_pointer > ownerDirEntries(ReadView const &view, AccountID const &account)
Return the ledger entries in an account's owner directory.
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
OwnerCount< ltTICKET > Tickets
Match the number of tickets on the account.
Definition ticket.h:54
json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
Definition flags.cpp:15
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ RpcChannelAmtMalformed
Definition ErrorCodes.h:84
@ RpcBadKeyType
Definition ErrorCodes.h:116
@ RpcActMalformed
Definition ErrorCodes.h:73
@ RpcPublicMalformed
Definition ErrorCodes.h:100
@ RpcInvalidParams
Definition ErrorCodes.h:67
@ RpcChannelMalformed
Definition ErrorCodes.h:83
void forAllApiVersions(Fn const &fn, Args &&... args)
Definition ApiVersion.h:159
std::string strHex(FwdIt begin, FwdIt end)
Definition strHex.h:13
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
@ USER
Definition Role.h:27
@ ADMIN
Definition Role.h:27
BaseUInt< 256 > UInt256
Definition base_uint.h:581
@ JtClient
Definition Job.h:31
json::Value doChannelVerify(rpc::JsonContext &context)
static std::string sliceToHex(Slice const &slice)
Definition PublicKey.cpp:77
@ temBAD_EXPIRATION
Definition TER.h:79
@ temDST_IS_SRC
Definition TER.h:96
@ temMALFORMED
Definition TER.h:75
@ temDISABLED
Definition TER.h:102
@ temBAD_AMOUNT
Definition TER.h:77
@ temBAD_SIGNATURE
Definition TER.h:93
@ temBAD_SIGNER
Definition TER.h:103
bool isTesSuccess(TER x) noexcept
Definition TER.h:686
TERSubset< CanCvtToTER > TER
Definition TER.h:657
@ tecUNFUNDED_PAYMENT
Definition TER.h:296
@ tecNO_ENTRY
Definition TER.h:317
@ tecBAD_CREDENTIALS
Definition TER.h:370
@ tecEXPIRED
Definition TER.h:325
@ tecNO_PERMISSION
Definition TER.h:316
@ tecDST_TAG_NEEDED
Definition TER.h:320
@ tecHAS_OBLIGATIONS
Definition TER.h:328
@ tecNO_DST
Definition TER.h:301
@ tecUNFUNDED
Definition TER.h:306
json::Value doChannelAuthorize(rpc::JsonContext &context)
@ tesSUCCESS
Definition TER.h:253
T reserve(T... args)
T size(T... args)
std::shared_ptr< JobQueue::Coro > coro
Definition Context.h:35
resource::Charge & loadType
Definition Context.h:30
json::Value params
Definition Context.h:51
void testSettleDelay(FeatureBitset features)
void testOptionalFields(FeatureBitset features)
void testSimple(FeatureBitset features)
void testMetaAndOwnership(FeatureBitset features)
void testMultiple(FeatureBitset features)
void testCancelAfter(FeatureBitset features)
void testWithFeats(FeatureBitset features)
void testDepositAuth(FeatureBitset features)
void testDefaultAmount(FeatureBitset features)
void testCloseDry(FeatureBitset features)
void testUsingTickets(FeatureBitset features)
void testDstTag(FeatureBitset features)
void testChannelAuthorizeLoadType(FeatureBitset features)
void testAccountChannelAuthorize(FeatureBitset features)
void testAccountChannelsRPC(FeatureBitset features)
void testExpiration(FeatureBitset features)
static std::optional< std::int64_t > channelExpiration(ReadView const &view, UInt256 const &chan)
void testDisallowIncoming(FeatureBitset features)
void testChannelVerifyLoadType(FeatureBitset features)
void testAuthVerifyRPC(FeatureBitset features)
void testAccountDelete(FeatureBitset features)
void run() override
Runs the suite.
static std::pair< UInt256, SLE::const_pointer > channelKeyAndSle(ReadView const &view, jtx::Account const &account, jtx::Account const &dst)
void testDisallowXRP(FeatureBitset features)
void testAccountChannelsRPCSenderOnly(FeatureBitset features)
void testMalformedPK(FeatureBitset features)
void testAccountChannelsRPCMarkers(FeatureBitset features)
T substr(T... args)
T to_string(T... args)