175 auto const alice =
Account(
"alice");
176 auto const bob =
Account(
"bob");
177 auto const charlie =
Account(
"charlie");
178 auto const daria =
Account(
"daria");
179 auto const elmo =
Account(
"elmo");
180 auto const fred =
Account(
"fred");
181 auto const gwen =
Account(
"gwen");
182 auto const hank =
Account(
"hank");
183 auto const iris =
Account(
"iris");
186 auto const baseFee = env.current()->fees().base.drops();
191 env.fund(
XRP(50000),
noripple(alice, bob, charlie, daria));
195 env(
noop(alice), queued);
203 env(
noop(daria),
Fee(baseFee * 100), queued);
213 env.fund(
XRP(50000),
noripple(elmo, fred, gwen, hank));
217 env(
noop(alice),
Fee(baseFee * 1.2), queued);
220 env(
noop(bob),
Fee(baseFee), queued);
221 env(
noop(charlie),
Fee(baseFee * 2), queued);
222 env(
noop(daria),
Fee(baseFee * 1.5), queued);
223 env(
noop(elmo),
Fee(baseFee * 1.1), queued);
224 env(
noop(fred),
Fee(baseFee * 1.9), queued);
225 env(
noop(gwen),
Fee(baseFee * 1.6), queued);
226 env(
noop(hank),
Fee(baseFee * 1.8), queued);
238 env(
noop(hank),
Fee(baseFee), queued);
250 env(
noop(hank),
Fee(baseFee * 600), queued);
263 env(
noop(hank),
Fee(baseFee * 2), queued);
273 env.close(env.now() + 5s, 10000ms);
282 static constexpr auto kLargeFeeMultiplier = 700;
283 auto const largeFee = baseFee * kLargeFeeMultiplier;
287 env(
noop(hank),
Fee(largeFee));
288 env(
noop(gwen),
Fee(largeFee));
289 env(
noop(fred),
Fee(largeFee));
290 env(
noop(elmo),
Fee(largeFee));
297 env(
noop(daria),
Fee(baseFee * 1.5), queued);
299 env(
noop(elmo),
Fee(baseFee * 1.6), queued);
300 env(
noop(fred),
Fee(baseFee * 1.7), queued);
301 env(
noop(gwen),
Fee(baseFee * 1.8), queued);
302 env(
noop(hank),
Fee(baseFee * 1.9), queued);
303 env(
noop(alice),
Fee(baseFee * 2.0), queued);
314 env(
noop(charlie),
Fee(baseFee * 10), queued);
341 env(
pay(alice, iris,
XRP(1000)), queued);
349 BEAST_EXPECT(env.seq(iris) == 11);
358 auto metrics = env.app().getTxQ().getMetrics(*env.current());
359 BEAST_EXPECT(
metrics.txCount == 0);
364 env(
noop(env.master));
368 env(
noop(env.master),
Fee(baseFee * 2), queued);
388 auto const alice =
Account(
"alice");
391 auto const baseFee = env.current()->fees().base.drops();
417 BEAST_EXPECT(env.seq(alice) == tkt1 + 250);
441 checkMetrics(*
this, env, 8, 8, 5, 4, expectedMinFeeLevel);
487 env(
noop(alice),
Seq(nextSeq + 0), queued);
491 env(
noop(alice),
Seq(nextSeq + 1), queued);
498 env(
noop(alice),
Seq(nextSeq + 2), queued);
499 env(
noop(alice),
Seq(nextSeq + 3), queued);
500 env(
noop(alice),
Seq(nextSeq + 4), queued);
501 env(
noop(alice),
Seq(nextSeq + 5), queued);
502 env(
noop(alice),
Seq(nextSeq + 6), queued);
533 BEAST_EXPECT(env.seq(alice) == nextSeq + 4);
581 BEAST_EXPECT(env.seq(alice) == nextSeq + 6);
592 Fee((baseFee * 2.1 * 1.25) - 1),
599 Fee((baseFee * 2.2 * 1.25) - 1),
614 BEAST_EXPECT(env.seq(alice) == nextSeq + 8);
716 auto const alice =
Account(
"alice");
717 auto const bob =
Account(
"bob");
718 auto const charlie =
Account(
"charlie");
719 auto const daria =
Account(
"daria");
720 auto const edgar =
Account(
"edgar");
721 auto const felicia =
Account(
"felicia");
724 auto const baseFee = env.current()->fees().base.drops();
730 env.close(env.now() + 5s, 10000ms);
732 env.close(env.now() + 5s, 10000ms);
734 env.close(env.now() + 5s, 10000ms);
742 BEAST_EXPECT(env.current()->header().seq == 6);
748 static constexpr auto kLargeFeeMultiplier = 700;
749 auto const largeFee = baseFee * kLargeFeeMultiplier;
753 env(
noop(bob),
Fee(largeFee), queued);
754 env(
noop(charlie),
Fee(largeFee), queued);
755 env(
noop(daria),
Fee(largeFee), queued);
756 env(
noop(edgar),
Fee(largeFee), queued);
759 auto const& txQ = env.app().getTxQ();
760 auto aliceStat = txQ.getAccountTxs(alice.id());
761 BEAST_EXPECT(aliceStat.size() == 1);
764 BEAST_EXPECT(aliceStat.begin()->lastValid && *aliceStat.begin()->lastValid == 8);
765 BEAST_EXPECT(!aliceStat.begin()->consequences.isBlocker());
767 auto bobStat = txQ.getAccountTxs(bob.id());
768 BEAST_EXPECT(bobStat.size() == 1);
770 bobStat.begin()->feeLevel ==
FeeLevel64{kBaseFeeLevel.fee() * kLargeFeeMultiplier});
771 BEAST_EXPECT(!bobStat.begin()->lastValid);
772 BEAST_EXPECT(!bobStat.begin()->consequences.isBlocker());
775 BEAST_EXPECT(noStat.empty());
782 env(
noop(bob),
Fee(largeFee), queued);
783 env(
noop(charlie),
Fee(largeFee), queued);
784 env(
noop(daria),
Fee(largeFee), queued);
785 env(
noop(edgar),
Fee(largeFee), queued);
786 env(
noop(felicia),
Fee(largeFee - 1), queued);
794 BEAST_EXPECT(env.seq(alice) == 3);
796 static constexpr auto kAnotherLargeFeeMultiplier = 800;
797 auto const anotherLargeFee = baseFee * kAnotherLargeFeeMultiplier;
800 env(
noop(bob),
Fee(anotherLargeFee), queued);
801 env(
noop(charlie),
Fee(anotherLargeFee), queued);
802 env(
noop(daria),
Fee(anotherLargeFee), queued);
803 env(
noop(daria),
Fee(anotherLargeFee),
Seq(env.seq(daria) + 1), queued);
804 env(
noop(edgar),
Fee(anotherLargeFee), queued);
805 env(
noop(felicia),
Fee(anotherLargeFee - 1), queued);
806 env(
noop(felicia),
Fee(anotherLargeFee - 1),
Seq(env.seq(felicia) + 1), queued);
817 BEAST_EXPECT(env.seq(alice) == 3);
818 BEAST_EXPECT(env.seq(felicia) == 7);
825 BEAST_EXPECT(env.seq(alice) == 3);
826 BEAST_EXPECT(env.seq(felicia) == 8);
1009 using namespace jtx;
1018 auto const alice =
Account(
"alice");
1019 auto const bob =
Account(
"bob");
1020 auto const charlie =
Account(
"charlie");
1021 auto const daria =
Account(
"daria");
1028 initFee(env, 3, 2, 10, 200, 50);
1037 env.fund(
XRP(500000),
noripple(bob, charlie, daria));
1041 env(
noop(alice),
Fee(11), queued);
1044 auto aliceSeq = env.seq(alice);
1045 auto bobSeq = env.seq(bob);
1046 auto charlieSeq = env.seq(charlie);
1053 env(
noop(alice),
Seq(aliceSeq + 1),
Fee(13), queued);
1057 env(
noop(alice),
Seq(aliceSeq + 2),
Fee(17), queued);
1061 env(
noop(bob), queued);
1065 env(
noop(bob),
Seq(bobSeq + 1),
Fee(50), queued);
1070 env(
noop(charlie),
Fee(15), queued);
1073 BEAST_EXPECT(env.seq(alice) == aliceSeq);
1074 BEAST_EXPECT(env.seq(bob) == bobSeq);
1075 BEAST_EXPECT(env.seq(charlie) == charlieSeq);
1085 BEAST_EXPECT(env.seq(alice) == aliceSeq + 3);
1086 BEAST_EXPECT(env.seq(bob) == bobSeq + 1);
1087 BEAST_EXPECT(env.seq(charlie) == charlieSeq + 1);
1091 aliceSeq = env.seq(alice);
1092 auto const lastLedgerSeq = env.current()->header().seq + 2;
1093 for (
auto i = 0; i < 7; i++)
1097 Json(jss::LastLedgerSequence, lastLedgerSeq + i),
1104 auto const& txQ = env.app().getTxQ();
1105 auto const aliceStat = txQ.getAccountTxs(alice.id());
1107 auto const& baseFee = env.current()->fees().base;
1108 auto seq = env.seq(alice);
1109 BEAST_EXPECT(aliceStat.size() == 7);
1110 for (
auto const& tx : aliceStat)
1112 BEAST_EXPECT(tx.seqProxy.isSeq() && tx.seqProxy.value() == seq);
1114 BEAST_EXPECT(tx.lastValid);
1116 (tx.consequences.fee() ==
drops(aliceFee) &&
1117 tx.consequences.potentialSpend() ==
drops(0) &&
1118 !tx.consequences.isBlocker()) ||
1119 tx.seqProxy.value() == env.seq(alice) + 6);
1129 Json(jss::LastLedgerSequence, lastLedgerSeq + 7),
1142 env(
noop(charlie),
Fee(30), queued);
1159 aliceSeq = env.seq(alice) + 2;
1166 env(
noop(alice),
Seq(aliceSeq),
Fee(aliceFee), queued);
1175 aliceSeq = env.seq(alice) + 1;
1181 aliceFee = env.le(alice)->getFieldAmount(sfBalance).xrp().drops() - 62;
1193 env(
noop(alice),
Seq(aliceSeq),
Fee(aliceFee), queued);
1218 bobSeq = env.seq(bob);
1220 for (
int i = 0; i < 10; ++i)
1221 env(
noop(bob),
Seq(bobSeq + i), queued);
1228 env(
noop(bob),
Seq(bobSeq + 5),
Fee(20), queued);
1234 std::int64_t bobFee = env.le(bob)->getFieldAmount(sfBalance).xrp().drops() - ((9 * 10) - 1);
1244 bobFee = env.le(bob)->getFieldAmount(sfBalance).xrp().drops() - (9 * 10);
1260 using namespace jtx;
1265 cfg->fees.referenceFee = 10;
1266 Env env(*
this, std::move(cfg));
1268 auto const alice =
Account(
"alice");
1269 auto const bob =
Account(
"bob");
1270 auto const charlie =
Account(
"charlie");
1271 auto const daria =
Account(
"daria");
1272 auto const elmo =
Account(
"elmo");
1273 auto const fred =
Account(
"fred");
1274 auto const gwen =
Account(
"gwen");
1275 auto const hank =
Account(
"hank");
1279 BEAST_EXPECT(env.
current()->fees().base == 10);
1307 auto aliceSeq = env.
seq(alice);
1308 auto bobSeq = env.
seq(bob);
1309 auto charlieSeq = env.
seq(charlie);
1310 auto dariaSeq = env.
seq(daria);
1311 auto elmoSeq = env.
seq(elmo);
1312 auto fredSeq = env.
seq(fred);
1313 auto gwenSeq = env.
seq(gwen);
1314 auto hankSeq = env.
seq(hank);
1320 env(
noop(alice),
Fee(15), queued);
1321 env(
noop(bob),
Fee(15), queued);
1322 env(
noop(charlie),
Fee(15), queued);
1323 env(
noop(daria),
Fee(15), queued);
1324 env(
noop(elmo),
Fee(15), queued);
1325 env(
noop(fred),
Fee(15), queued);
1326 env(
noop(gwen),
Fee(15), queued);
1327 env(
noop(hank),
Fee(15), queued);
1342 env(
noop(charlie),
Fee(100),
Seq(charlieSeq + 1), queued);
1356 aliceSeq + bobSeq + charlieSeq + dariaSeq + elmoSeq + fredSeq + gwenSeq + hankSeq + 6 ==
1357 env.
seq(alice) + env.
seq(bob) + env.
seq(charlie) + env.
seq(daria) + env.
seq(elmo) +
1358 env.
seq(fred) + env.
seq(gwen) + env.
seq(hank));
1360 using namespace std::string_literals;
1362 aliceSeq == env.
seq(alice),
1365 bobSeq + 1 == env.
seq(bob),
1368 charlieSeq + 2 == env.
seq(charlie),
1371 dariaSeq == env.
seq(daria),
1374 elmoSeq + 1 == env.
seq(elmo),
1377 fredSeq == env.
seq(fred),
1380 gwenSeq + 1 == env.
seq(gwen),
1383 hankSeq + 1 == env.
seq(hank),
1397 auto const getTxsQueued = [&] {
1400 for (
auto const& tx : txs)
1402 ++result[tx.txn->at(sfAccount)];
1406 auto qTxCount1 = getTxsQueued();
1407 BEAST_EXPECT(qTxCount1.size() <= 3);
1410 env(
noop(alice),
Seq(aliceSeq + qTxCount1[alice.id()]++),
Fee(15), queued);
1411 env(
noop(bob),
Seq(bobSeq + qTxCount1[bob.id()]++),
Fee(15), queued);
1412 env(
noop(charlie),
Seq(charlieSeq + qTxCount1[charlie.id()]++),
Fee(15), queued);
1413 env(
noop(daria),
Seq(dariaSeq + qTxCount1[daria.id()]++),
Fee(15), queued);
1414 env(
noop(elmo),
Seq(elmoSeq + qTxCount1[elmo.id()]++),
Fee(15), queued);
1415 env(
noop(fred),
Seq(fredSeq + qTxCount1[fred.id()]++),
Fee(15), queued);
1416 env(
noop(gwen),
Seq(gwenSeq + qTxCount1[gwen.id()]++),
Fee(15), queued);
1424 env(
noop(alice),
Fee(100),
Seq(aliceSeq + qTxCount1[alice.id()]++), queued);
1435 auto qTxCount2 = getTxsQueued();
1436 BEAST_EXPECT(qTxCount2.size() <= 4);
1441 aliceSeq + bobSeq + charlieSeq + dariaSeq + elmoSeq + fredSeq + gwenSeq + hankSeq + 7 ==
1442 env.
seq(alice) + env.
seq(bob) + env.
seq(charlie) + env.
seq(daria) + env.
seq(elmo) +
1443 env.
seq(fred) + env.
seq(gwen) + env.
seq(hank));
1446 aliceSeq + qTxCount1[alice.id()] - qTxCount2[alice.id()] == env.
seq(alice),
1449 bobSeq + qTxCount1[bob.id()] - qTxCount2[bob.id()] == env.
seq(bob),
1452 charlieSeq + qTxCount1[charlie.id()] - qTxCount2[charlie.id()] == env.
seq(charlie),
1455 dariaSeq + qTxCount1[daria.id()] - qTxCount2[daria.id()] == env.
seq(daria),
1458 elmoSeq + qTxCount1[elmo.id()] - qTxCount2[elmo.id()] == env.
seq(elmo),
1461 fredSeq + qTxCount1[fred.id()] - qTxCount2[fred.id()] == env.
seq(fred),
1464 gwenSeq + qTxCount1[gwen.id()] - qTxCount2[gwen.id()] == env.
seq(gwen),
1467 hankSeq + qTxCount1[hank.id()] - qTxCount2[hank.id()] == env.
seq(hank),
2000 using namespace jtx;
2001 testcase(
"In-flight balance checks");
2009 auto const alice =
Account(
"alice");
2010 auto const charlie =
Account(
"charlie");
2011 auto const gw =
Account(
"gw");
2021 auto const initQueueMax =
initFee(env, 3, 2, 10, 200, 50);
2027 env.fund(
XRP(50000),
noripple(alice, charlie), gw);
2028 checkMetrics(*
this, env, 0, initQueueMax, limit + 1, limit);
2030 auto const usd = gw[
"USD"];
2031 auto const bux = gw[
"BUX"];
2035 auto aliceSeq = env.seq(alice);
2036 auto aliceBal = env.balance(alice);
2042 env(
offer(alice, bux(5000),
XRP(50000)), queued);
2043 checkMetrics(*
this, env, 1, initQueueMax, limit + 1, limit);
2047 env(
noop(alice),
Seq(aliceSeq + 1), queued);
2048 checkMetrics(*
this, env, 2, initQueueMax, limit + 1, limit);
2064 checkMetrics(*
this, env, 0, limit * 2, limit + 1, limit);
2065 aliceSeq = env.seq(alice);
2066 aliceBal = env.balance(alice);
2068 env.require(
Owners(alice, 0));
2072 checkMetrics(*
this, env, 1, limit * 2, limit + 1, limit);
2077 checkMetrics(*
this, env, 2, limit * 2, limit + 1, limit);
2082 checkMetrics(*
this, env, 2, limit * 2, limit + 1, limit);
2098 checkMetrics(*
this, env, 0, limit * 2, limit + 1, limit);
2099 aliceSeq = env.seq(alice);
2100 aliceBal = env.balance(alice);
2102 env.require(
Owners(alice, 0));
2107 checkMetrics(*
this, env, 1, limit * 2, limit + 1, limit);
2112 checkMetrics(*
this, env, 1, limit * 2, limit + 1, limit);
2128 checkMetrics(*
this, env, 0, limit * 2, limit + 1, limit);
2129 aliceSeq = env.seq(alice);
2130 aliceBal = env.balance(alice);
2134 env(
offer(alice, bux(50),
XRP(500)), queued);
2137 env(
noop(alice),
Seq(aliceSeq + 1), queued);
2138 checkMetrics(*
this, env, 2, limit * 2, limit + 1, limit);
2154 checkMetrics(*
this, env, 0, limit * 2, limit + 1, limit);
2156 aliceSeq = env.seq(alice);
2157 aliceBal = env.balance(alice);
2162 env(
pay(alice, charlie,
XRP(50000)), queued);
2166 env(
noop(alice),
Seq(aliceSeq + 1), queued);
2167 checkMetrics(*
this, env, 2, limit * 2, limit + 1, limit);
2181 checkMetrics(*
this, env, 0, limit * 2, limit + 1, limit);
2183 aliceSeq = env.seq(alice);
2184 aliceBal = env.balance(alice);
2188 env(
pay(alice, charlie,
XRP(500)), queued);
2191 env(
noop(alice),
Seq(aliceSeq + 1), queued);
2192 checkMetrics(*
this, env, 2, limit * 2, limit + 1, limit);
2203 auto const amount = usd(500000);
2204 env(
trust(alice, usd(50000000)));
2205 env(
trust(charlie, usd(50000000)));
2211 env(
pay(gw, alice, amount));
2218 checkMetrics(*
this, env, 0, limit * 2, limit + 1, limit);
2220 aliceSeq = env.seq(alice);
2221 aliceBal = env.balance(alice);
2222 auto const aliceUSD = env.balance(alice, usd);
2226 env(
pay(alice, charlie, amount), queued);
2230 env(
noop(alice),
Seq(aliceSeq + 1), queued);
2231 checkMetrics(*
this, env, 2, limit * 2, limit + 1, limit);
2249 env(
offer(gw,
XRP(500000), usd(50000)));
2255 checkMetrics(*
this, env, 0, limit * 2, limit + 1, limit);
2257 aliceSeq = env.seq(alice);
2258 aliceBal = env.balance(alice);
2259 auto charlieUSD = env.balance(charlie, usd);
2265 BEAST_EXPECT(
XRP(60000) > aliceBal);
2266 env(
pay(alice, charlie, usd(1000)),
Sendmax(
XRP(60000)), queued);
2270 env(
noop(alice),
Seq(aliceSeq + 1), queued);
2271 checkMetrics(*
this, env, 2, limit * 2, limit + 1, limit);
2282 Balance(charlie, charlieUSD + usd(1000)),
2290 checkMetrics(*
this, env, 0, limit * 2, limit + 1, limit);
2292 aliceSeq = env.seq(alice);
2293 aliceBal = env.balance(alice);
2294 charlieUSD = env.balance(charlie, usd);
2300 BEAST_EXPECT(aliceBal >
XRP(6001));
2301 env(
pay(alice, charlie, usd(500)),
Sendmax(
XRP(6000)), queued);
2304 env(
noop(alice),
Seq(aliceSeq + 1), queued);
2305 checkMetrics(*
this, env, 2, limit * 2, limit + 1, limit);
2316 Balance(charlie, charlieUSD + usd(500)),
2326 checkMetrics(*
this, env, 0, limit * 2, limit + 1, limit);
2328 aliceSeq = env.seq(alice);
2329 aliceBal = env.balance(alice);
2330 BEAST_EXPECT(aliceBal ==
drops(30));
2334 BEAST_EXPECT(env.balance(alice) ==
drops(30));
2336 checkMetrics(*
this, env, 1, limit * 2, limit + 1, limit);
2341 BEAST_EXPECT(env.balance(alice) ==
drops(5));
2570 using namespace jtx;
2575 auto fee = env.
rpc(
"fee");
2577 if (BEAST_EXPECT(fee.isMember(jss::result)) &&
2580 auto const& result = fee[jss::result];
2582 result.isMember(jss::ledger_current_index) &&
2583 result[jss::ledger_current_index] == 3);
2584 BEAST_EXPECT(result.isMember(jss::current_ledger_size));
2585 BEAST_EXPECT(result.isMember(jss::current_queue_size));
2586 BEAST_EXPECT(result.isMember(jss::expected_ledger_size));
2587 BEAST_EXPECT(!result.isMember(jss::max_queue_size));
2588 BEAST_EXPECT(result.isMember(jss::drops));
2589 auto const&
drops = result[jss::drops];
2590 BEAST_EXPECT(
drops.isMember(jss::base_fee));
2591 BEAST_EXPECT(
drops.isMember(jss::median_fee));
2592 BEAST_EXPECT(
drops.isMember(jss::minimum_fee));
2593 BEAST_EXPECT(
drops.isMember(jss::open_ledger_fee));
2594 BEAST_EXPECT(result.isMember(jss::levels));
2595 auto const& levels = result[jss::levels];
2596 BEAST_EXPECT(levels.isMember(jss::median_level));
2597 BEAST_EXPECT(levels.isMember(jss::minimum_level));
2598 BEAST_EXPECT(levels.isMember(jss::open_ledger_level));
2599 BEAST_EXPECT(levels.isMember(jss::reference_level));
2604 fee = env.
rpc(
"fee");
2606 if (BEAST_EXPECT(fee.isMember(jss::result)) &&
2609 auto const& result = fee[jss::result];
2611 result.isMember(jss::ledger_current_index) &&
2612 result[jss::ledger_current_index] == 4);
2613 BEAST_EXPECT(result.isMember(jss::current_ledger_size));
2614 BEAST_EXPECT(result.isMember(jss::current_queue_size));
2615 BEAST_EXPECT(result.isMember(jss::expected_ledger_size));
2616 BEAST_EXPECT(result.isMember(jss::max_queue_size));
2617 auto const&
drops = result[jss::drops];
2618 BEAST_EXPECT(
drops.isMember(jss::base_fee));
2619 BEAST_EXPECT(
drops.isMember(jss::median_fee));
2620 BEAST_EXPECT(
drops.isMember(jss::minimum_fee));
2621 BEAST_EXPECT(
drops.isMember(jss::open_ledger_fee));
2622 BEAST_EXPECT(result.isMember(jss::levels));
2623 auto const& levels = result[jss::levels];
2624 BEAST_EXPECT(levels.isMember(jss::median_level));
2625 BEAST_EXPECT(levels.isMember(jss::minimum_level));
2626 BEAST_EXPECT(levels.isMember(jss::open_ledger_level));
2627 BEAST_EXPECT(levels.isMember(jss::reference_level));
2866 testcase(
"Autofilled sequence should account for TxQ");
2867 using namespace jtx;
2869 auto const baseFee = env.
current()->fees().base.drops();
2871 auto const& txQ = env.app().getTxQ();
2873 auto const alice =
Account(
"alice");
2874 auto const bob =
Account(
"bob");
2875 env.fund(
XRP(100000), alice, bob);
2881 auto const aliceSeq = env.seq(alice);
2882 auto const lastLedgerSeq = env.current()->header().seq + 2;
2885 for (
int i = 0; i < 5; ++i)
2893 Json(jss::LastLedgerSequence, lastLedgerSeq),
2903 auto const aliceStat = txQ.getAccountTxs(alice.id());
2905 BEAST_EXPECT(aliceStat.size() == 5);
2906 for (
auto const& tx : aliceStat)
2908 BEAST_EXPECT(tx.seqProxy == seq);
2909 BEAST_EXPECT(tx.feeLevel ==
FeeLevel64{kBaseFeeLevel.fee() * 100});
2910 if (seq.
value() == aliceSeq + 2)
2912 BEAST_EXPECT(tx.lastValid && *tx.lastValid == lastLedgerSeq);
2916 BEAST_EXPECT(!tx.lastValid);
2923 for (
int i = 0; i < 8; ++i)
2932 for (
int i = 0; i < 9; ++i)
2939 for (
int i = 0; i < 10; ++i)
2946 auto const bobStat = txQ.getAccountTxs(bob.id());
2947 BEAST_EXPECT(bobStat.empty());
2952 auto const aliceStat = txQ.getAccountTxs(alice.id());
2953 auto seq = aliceSeq;
2954 BEAST_EXPECT(aliceStat.size() == 4);
2955 for (
auto const& tx : aliceStat)
2958 if (seq == aliceSeq + 2)
2961 BEAST_EXPECT(tx.seqProxy.isSeq() && tx.seqProxy.value() == seq);
2962 BEAST_EXPECT(tx.feeLevel ==
FeeLevel64{kBaseFeeLevel.fee() * 100});
2963 BEAST_EXPECT(!tx.lastValid);
2971 auto const aliceStat = txQ.getAccountTxs(alice.id());
2972 auto seq = aliceSeq;
2973 BEAST_EXPECT(aliceStat.size() == 5);
2974 for (
auto const& tx : aliceStat)
2976 BEAST_EXPECT(tx.seqProxy.isSeq() && tx.seqProxy.value() == seq);
2977 BEAST_EXPECT(tx.feeLevel ==
FeeLevel64{kBaseFeeLevel * 100});
2978 BEAST_EXPECT(!tx.lastValid);
2987 auto const bobStat = txQ.getAccountTxs(bob.id());
2988 BEAST_EXPECT(bobStat.empty());
2991 auto const aliceStat = txQ.getAccountTxs(alice.id());
2992 BEAST_EXPECT(aliceStat.empty());
2999 using namespace jtx;
3003 auto const baseFee = env.
current()->fees().base.drops();
3007 env.fund(
XRP(1000000), alice);
3011 withQueue[jss::account] = alice.
human();
3012 withQueue[jss::queue] =
true;
3015 withoutQueue[jss::account] = alice.
human();
3018 prevLedgerWithQueue[jss::account] = alice.
human();
3019 prevLedgerWithQueue[jss::queue] =
true;
3020 prevLedgerWithQueue[jss::ledger_index] = 3;
3021 BEAST_EXPECT(env.current()->header().seq > 3);
3025 auto const info = env.rpc(
"json",
"account_info",
to_string(withoutQueue));
3027 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
3028 BEAST_EXPECT(!info[jss::result].isMember(jss::queue_data));
3032 auto const info = env.rpc(
"json",
"account_info",
to_string(withQueue));
3034 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
3035 auto const& result = info[jss::result];
3036 BEAST_EXPECT(result.isMember(jss::queue_data));
3037 auto const& queueData = result[jss::queue_data];
3038 BEAST_EXPECT(queueData.isObject());
3039 BEAST_EXPECT(queueData.isMember(jss::txn_count));
3040 BEAST_EXPECT(queueData[jss::txn_count] == 0);
3041 BEAST_EXPECT(!queueData.isMember(jss::lowest_sequence));
3042 BEAST_EXPECT(!queueData.isMember(jss::highest_sequence));
3043 BEAST_EXPECT(!queueData.isMember(jss::auth_change_queued));
3044 BEAST_EXPECT(!queueData.isMember(jss::max_spend_drops_total));
3045 BEAST_EXPECT(!queueData.isMember(jss::transactions));
3053 auto const info = env.rpc(
"json",
"account_info",
to_string(withQueue));
3055 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
3056 auto const& result = info[jss::result];
3057 BEAST_EXPECT(result.isMember(jss::queue_data));
3058 auto const& queueData = result[jss::queue_data];
3059 BEAST_EXPECT(queueData.isObject());
3060 BEAST_EXPECT(queueData.isMember(jss::txn_count));
3061 BEAST_EXPECT(queueData[jss::txn_count] == 0);
3062 BEAST_EXPECT(!queueData.isMember(jss::lowest_sequence));
3063 BEAST_EXPECT(!queueData.isMember(jss::highest_sequence));
3064 BEAST_EXPECT(!queueData.isMember(jss::auth_change_queued));
3065 BEAST_EXPECT(!queueData.isMember(jss::max_spend_drops_total));
3066 BEAST_EXPECT(!queueData.isMember(jss::transactions));
3077 auto const info = env.rpc(
"json",
"account_info",
to_string(withQueue));
3079 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
3080 auto const& result = info[jss::result];
3081 auto const&
data = result[jss::account_data];
3082 BEAST_EXPECT(result.isMember(jss::queue_data));
3083 auto const& queueData = result[jss::queue_data];
3084 BEAST_EXPECT(queueData.isObject());
3085 BEAST_EXPECT(queueData.isMember(jss::txn_count));
3086 BEAST_EXPECT(queueData[jss::txn_count] == 4);
3087 BEAST_EXPECT(queueData.isMember(jss::lowest_sequence));
3088 BEAST_EXPECT(queueData[jss::lowest_sequence] ==
data[jss::Sequence]);
3089 BEAST_EXPECT(queueData.isMember(jss::highest_sequence));
3091 queueData[jss::highest_sequence] ==
3092 data[jss::Sequence].asUInt() + queueData[jss::txn_count].asUInt() - 1);
3093 BEAST_EXPECT(queueData.isMember(jss::auth_change_queued));
3094 BEAST_EXPECT(queueData[jss::auth_change_queued] ==
false);
3095 BEAST_EXPECT(queueData.isMember(jss::max_spend_drops_total));
3096 BEAST_EXPECT(queueData[jss::max_spend_drops_total] ==
std::to_string(baseFee * 40));
3097 BEAST_EXPECT(queueData.isMember(jss::transactions));
3098 auto const& queued = queueData[jss::transactions];
3099 BEAST_EXPECT(queued.size() == queueData[jss::txn_count]);
3100 for (
unsigned i = 0; i < queued.size(); ++i)
3102 auto const& item = queued[i];
3103 BEAST_EXPECT(item[jss::seq] ==
data[jss::Sequence].asInt() + i);
3105 BEAST_EXPECT(!item.isMember(jss::LastLedgerSequence));
3107 BEAST_EXPECT(item.isMember(jss::fee));
3109 BEAST_EXPECT(item.isMember(jss::max_spend_drops));
3110 BEAST_EXPECT(item[jss::max_spend_drops] ==
std::to_string(baseFee * 10));
3111 BEAST_EXPECT(item.isMember(jss::auth_change));
3112 BEAST_EXPECT(item[jss::auth_change].asBool() ==
false);
3124 fset(alice, asfAccountTxnID),
3127 Json(jss::LastLedgerSequence, 10),
3132 auto const info = env.rpc(
"json",
"account_info",
to_string(withQueue));
3134 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
3135 auto const& result = info[jss::result];
3136 auto const&
data = result[jss::account_data];
3137 BEAST_EXPECT(result.isMember(jss::queue_data));
3138 auto const& queueData = result[jss::queue_data];
3139 BEAST_EXPECT(queueData.isObject());
3140 BEAST_EXPECT(queueData.isMember(jss::txn_count));
3141 BEAST_EXPECT(queueData[jss::txn_count] == 1);
3142 BEAST_EXPECT(queueData.isMember(jss::lowest_sequence));
3143 BEAST_EXPECT(queueData[jss::lowest_sequence] ==
data[jss::Sequence]);
3144 BEAST_EXPECT(queueData.isMember(jss::highest_sequence));
3146 queueData[jss::highest_sequence] ==
3147 data[jss::Sequence].asUInt() + queueData[jss::txn_count].asUInt() - 1);
3148 BEAST_EXPECT(queueData.isMember(jss::auth_change_queued));
3149 BEAST_EXPECT(queueData[jss::auth_change_queued] ==
true);
3150 BEAST_EXPECT(queueData.isMember(jss::max_spend_drops_total));
3151 BEAST_EXPECT(queueData[jss::max_spend_drops_total] ==
std::to_string(baseFee * 10));
3152 BEAST_EXPECT(queueData.isMember(jss::transactions));
3153 auto const& queued = queueData[jss::transactions];
3154 BEAST_EXPECT(queued.size() == queueData[jss::txn_count]);
3155 for (
unsigned i = 0; i < queued.size(); ++i)
3157 auto const& item = queued[i];
3158 BEAST_EXPECT(item[jss::seq] ==
data[jss::Sequence].asInt() + i);
3160 BEAST_EXPECT(item.isMember(jss::fee));
3162 BEAST_EXPECT(item.isMember(jss::max_spend_drops));
3163 BEAST_EXPECT(item[jss::max_spend_drops] ==
std::to_string(baseFee * 10));
3164 BEAST_EXPECT(item.isMember(jss::auth_change));
3166 if (i == queued.size() - 1)
3168 BEAST_EXPECT(item[jss::auth_change].asBool() ==
true);
3169 BEAST_EXPECT(item.isMember(jss::LastLedgerSequence));
3170 BEAST_EXPECT(item[jss::LastLedgerSequence] == 10);
3174 BEAST_EXPECT(item[jss::auth_change].asBool() ==
false);
3175 BEAST_EXPECT(!item.isMember(jss::LastLedgerSequence));
3185 auto const info = env.rpc(
"json",
"account_info",
to_string(withQueue));
3187 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
3188 auto const& result = info[jss::result];
3189 auto const&
data = result[jss::account_data];
3190 BEAST_EXPECT(result.isMember(jss::queue_data));
3191 auto const& queueData = result[jss::queue_data];
3192 BEAST_EXPECT(queueData.isObject());
3193 BEAST_EXPECT(queueData.isMember(jss::txn_count));
3194 BEAST_EXPECT(queueData[jss::txn_count] == 1);
3195 BEAST_EXPECT(queueData.isMember(jss::lowest_sequence));
3196 BEAST_EXPECT(queueData[jss::lowest_sequence] ==
data[jss::Sequence]);
3197 BEAST_EXPECT(queueData.isMember(jss::highest_sequence));
3199 queueData[jss::highest_sequence] ==
3200 data[jss::Sequence].asUInt() + queueData[jss::txn_count].asUInt() - 1);
3201 BEAST_EXPECT(queueData.isMember(jss::auth_change_queued));
3202 BEAST_EXPECT(queueData[jss::auth_change_queued].asBool());
3203 BEAST_EXPECT(queueData.isMember(jss::max_spend_drops_total));
3204 BEAST_EXPECT(queueData[jss::max_spend_drops_total] ==
std::to_string(baseFee * 10));
3205 BEAST_EXPECT(queueData.isMember(jss::transactions));
3206 auto const& queued = queueData[jss::transactions];
3207 BEAST_EXPECT(queued.size() == queueData[jss::txn_count]);
3208 for (
unsigned i = 0; i < queued.size(); ++i)
3210 auto const& item = queued[i];
3211 BEAST_EXPECT(item[jss::seq] ==
data[jss::Sequence].asInt() + i);
3214 if (i == queued.size() - 1)
3216 BEAST_EXPECT(item.isMember(jss::fee));
3218 BEAST_EXPECT(item.isMember(jss::max_spend_drops));
3219 BEAST_EXPECT(item[jss::max_spend_drops] ==
std::to_string(baseFee * 10));
3220 BEAST_EXPECT(item.isMember(jss::auth_change));
3221 BEAST_EXPECT(item[jss::auth_change].asBool());
3222 BEAST_EXPECT(item.isMember(jss::LastLedgerSequence));
3223 BEAST_EXPECT(item[jss::LastLedgerSequence] == 10);
3227 BEAST_EXPECT(item.isMember(jss::fee));
3229 BEAST_EXPECT(item.isMember(jss::max_spend_drops));
3230 BEAST_EXPECT(item[jss::max_spend_drops] ==
std::to_string(baseFee * 10));
3231 BEAST_EXPECT(item.isMember(jss::auth_change));
3232 BEAST_EXPECT(!item[jss::auth_change].asBool());
3233 BEAST_EXPECT(!item.isMember(jss::LastLedgerSequence));
3239 auto const info = env.rpc(
"json",
"account_info",
to_string(prevLedgerWithQueue));
3240 BEAST_EXPECT(info[jss::result][jss::error] ==
"invalidParams");
3242 BEAST_EXPECT(info[jss::result][jss::error_message] ==
"Invalid parameters.");
3251 auto const info = env.rpc(
"json",
"account_info",
to_string(withQueue));
3253 info.isMember(jss::result) && info[jss::result].isMember(jss::account_data));
3254 auto const& result = info[jss::result];
3255 BEAST_EXPECT(result.isMember(jss::queue_data));
3256 auto const& queueData = result[jss::queue_data];
3257 BEAST_EXPECT(queueData.isObject());
3258 BEAST_EXPECT(queueData.isMember(jss::txn_count));
3259 BEAST_EXPECT(queueData[jss::txn_count] == 0);
3260 BEAST_EXPECT(!queueData.isMember(jss::lowest_sequence));
3261 BEAST_EXPECT(!queueData.isMember(jss::highest_sequence));
3262 BEAST_EXPECT(!queueData.isMember(jss::auth_change_queued));
3263 BEAST_EXPECT(!queueData.isMember(jss::max_spend_drops_total));
3264 BEAST_EXPECT(!queueData.isMember(jss::transactions));
3271 using namespace jtx;
3275 auto const baseFee = env.
current()->fees().base.drops();
3279 env.fund(
XRP(1000000), alice);
3283 auto const serverInfo = env.rpc(
"server_info");
3285 serverInfo.isMember(jss::result) && serverInfo[jss::result].isMember(jss::info));
3286 auto const& info = serverInfo[jss::result][jss::info];
3287 BEAST_EXPECT(info.isMember(jss::load_factor) && info[jss::load_factor] == 1);
3288 BEAST_EXPECT(!info.isMember(jss::load_factor_server));
3289 BEAST_EXPECT(!info.isMember(jss::load_factor_local));
3290 BEAST_EXPECT(!info.isMember(jss::load_factor_net));
3291 BEAST_EXPECT(!info.isMember(jss::load_factor_fee_escalation));
3294 auto const serverState = env.rpc(
"server_state");
3295 auto const& state = serverState[jss::result][jss::state];
3296 BEAST_EXPECT(state.isMember(jss::load_factor) && state[jss::load_factor] == 256);
3297 BEAST_EXPECT(state.isMember(jss::load_base) && state[jss::load_base] == 256);
3299 state.isMember(jss::load_factor_server) && state[jss::load_factor_server] == 256);
3301 state.isMember(jss::load_factor_fee_escalation) &&
3302 state[jss::load_factor_fee_escalation] == 256);
3304 state.isMember(jss::load_factor_fee_queue) &&
3305 state[jss::load_factor_fee_queue] == 256);
3307 state.isMember(jss::load_factor_fee_reference) &&
3308 state[jss::load_factor_fee_reference] == 256);
3316 auto aliceSeq = env.seq(alice);
3318 for (
auto i = 0; i < 4; ++i)
3323 auto const serverInfo = env.rpc(
"server_info");
3325 serverInfo.isMember(jss::result) && serverInfo[jss::result].isMember(jss::info));
3326 auto const& info = serverInfo[jss::result][jss::info];
3329 info.isMember(jss::load_factor) && info[jss::load_factor] > 888.88 &&
3330 info[jss::load_factor] < 888.89);
3332 info.isMember(jss::load_factor_server) && info[jss::load_factor_server] == 1);
3333 BEAST_EXPECT(!info.isMember(jss::load_factor_local));
3334 BEAST_EXPECT(!info.isMember(jss::load_factor_net));
3336 info.isMember(jss::load_factor_fee_escalation) &&
3337 info[jss::load_factor_fee_escalation] > 888.88 &&
3338 info[jss::load_factor_fee_escalation] < 888.89);
3341 auto const serverState = env.rpc(
"server_state");
3342 auto const& state = serverState[jss::result][jss::state];
3343 BEAST_EXPECT(state.isMember(jss::load_factor) && state[jss::load_factor] == 227555);
3344 BEAST_EXPECT(state.isMember(jss::load_base) && state[jss::load_base] == 256);
3346 state.isMember(jss::load_factor_server) && state[jss::load_factor_server] == 256);
3348 state.isMember(jss::load_factor_fee_escalation) &&
3349 state[jss::load_factor_fee_escalation] == 227555);
3351 state.isMember(jss::load_factor_fee_queue) &&
3352 state[jss::load_factor_fee_queue] == 256);
3354 state.isMember(jss::load_factor_fee_reference) &&
3355 state[jss::load_factor_fee_reference] == 256);
3358 env.app().getFeeTrack().setRemoteFee(256000);
3361 auto const serverInfo = env.rpc(
"server_info");
3363 serverInfo.isMember(jss::result) && serverInfo[jss::result].isMember(jss::info));
3364 auto const& info = serverInfo[jss::result][jss::info];
3366 BEAST_EXPECT(info.isMember(jss::load_factor) && info[jss::load_factor] == 1000);
3367 BEAST_EXPECT(!info.isMember(jss::load_factor_server));
3368 BEAST_EXPECT(!info.isMember(jss::load_factor_local));
3369 BEAST_EXPECT(info.isMember(jss::load_factor_net) && info[jss::load_factor_net] == 1000);
3371 info.isMember(jss::load_factor_fee_escalation) &&
3372 info[jss::load_factor_fee_escalation] > 888.88 &&
3373 info[jss::load_factor_fee_escalation] < 888.89);
3376 auto const serverState = env.rpc(
"server_state");
3377 auto const& state = serverState[jss::result][jss::state];
3378 BEAST_EXPECT(state.isMember(jss::load_factor) && state[jss::load_factor] == 256000);
3379 BEAST_EXPECT(state.isMember(jss::load_base) && state[jss::load_base] == 256);
3381 state.isMember(jss::load_factor_server) &&
3382 state[jss::load_factor_server] == 256000);
3384 state.isMember(jss::load_factor_fee_escalation) &&
3385 state[jss::load_factor_fee_escalation] == 227555);
3387 state.isMember(jss::load_factor_fee_queue) &&
3388 state[jss::load_factor_fee_queue] == 256);
3390 state.isMember(jss::load_factor_fee_reference) &&
3391 state[jss::load_factor_fee_reference] == 256);
3394 env.app().getFeeTrack().setRemoteFee(256);
3397 for (
int i = 0; i < 5; ++i)
3398 env.app().getFeeTrack().raiseLocalFee();
3399 BEAST_EXPECT(env.app().getFeeTrack().getLoadFactor() == 625);
3402 auto const serverInfo = env.rpc(
"server_info");
3404 serverInfo.isMember(jss::result) && serverInfo[jss::result].isMember(jss::info));
3405 auto const& info = serverInfo[jss::result][jss::info];
3408 info.isMember(jss::load_factor) && info[jss::load_factor] > 888.88 &&
3409 info[jss::load_factor] < 888.89);
3414 info.isMember(jss::load_factor_server) && info[jss::load_factor_server] > 1.245 &&
3415 info[jss::load_factor_server] < 2.4415);
3417 info.isMember(jss::load_factor_local) && info[jss::load_factor_local] > 1.245 &&
3418 info[jss::load_factor_local] < 2.4415);
3419 BEAST_EXPECT(!info.isMember(jss::load_factor_net));
3421 info.isMember(jss::load_factor_fee_escalation) &&
3422 info[jss::load_factor_fee_escalation] > 888.88 &&
3423 info[jss::load_factor_fee_escalation] < 888.89);
3426 auto const serverState = env.rpc(
"server_state");
3427 auto const& state = serverState[jss::result][jss::state];
3428 BEAST_EXPECT(state.isMember(jss::load_factor) && state[jss::load_factor] == 227555);
3429 BEAST_EXPECT(state.isMember(jss::load_base) && state[jss::load_base] == 256);
3434 state.isMember(jss::load_factor_server) && state[jss::load_factor_server] >= 320 &&
3435 state[jss::load_factor_server] <= 625);
3437 state.isMember(jss::load_factor_fee_escalation) &&
3438 state[jss::load_factor_fee_escalation] == 227555);
3440 state.isMember(jss::load_factor_fee_queue) &&
3441 state[jss::load_factor_fee_queue] == 256);
3443 state.isMember(jss::load_factor_fee_reference) &&
3444 state[jss::load_factor_fee_reference] == 256);
3450 auto const serverInfo = env.rpc(
"server_info");
3452 serverInfo.isMember(jss::result) && serverInfo[jss::result].isMember(jss::info));
3453 auto const& info = serverInfo[jss::result][jss::info];
3460 info.isMember(jss::load_factor) && info[jss::load_factor] > 1.245 &&
3461 info[jss::load_factor] < 2.4415);
3462 BEAST_EXPECT(!info.isMember(jss::load_factor_server));
3464 info.isMember(jss::load_factor_local) && info[jss::load_factor_local] > 1.245 &&
3465 info[jss::load_factor_local] < 2.4415);
3466 BEAST_EXPECT(!info.isMember(jss::load_factor_net));
3467 BEAST_EXPECT(!info.isMember(jss::load_factor_fee_escalation));
3470 auto const serverState = env.rpc(
"server_state");
3471 auto const& state = serverState[jss::result][jss::state];
3473 state.isMember(jss::load_factor) && state[jss::load_factor] >= 320 &&
3474 state[jss::load_factor] <= 625);
3475 BEAST_EXPECT(state.isMember(jss::load_base) && state[jss::load_base] == 256);
3480 state.isMember(jss::load_factor_server) && state[jss::load_factor_server] >= 320 &&
3481 state[jss::load_factor_server] <= 625);
3483 state.isMember(jss::load_factor_fee_escalation) &&
3484 state[jss::load_factor_fee_escalation] == 256);
3486 state.isMember(jss::load_factor_fee_queue) &&
3487 state[jss::load_factor_fee_queue] == 256);
3489 state.isMember(jss::load_factor_fee_reference) &&
3490 state[jss::load_factor_fee_reference] == 256);
3497 using namespace jtx;
3501 auto const baseFee = env.
current()->fees().base.drops();
3505 stream[jss::streams].append(
"server");
3508 auto jv = wsc->invoke(
"subscribe", stream);
3509 BEAST_EXPECT(jv[jss::status] ==
"success");
3513 Account a{
"a"}, b{
"b"}, c{
"c"}, d{
"d"}, e{
"e"}, f{
"f"}, g{
"g"}, h{
"h"}, i{
"i"};
3520 using namespace std::chrono_literals;
3521 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
3522 return jv[jss::type] ==
"serverStatus" && jv.isMember(jss::load_factor) &&
3523 jv[jss::load_factor] == 256 && jv.isMember(jss::load_base) &&
3524 jv[jss::load_base] == 256 && jv.isMember(jss::load_factor_server) &&
3525 jv[jss::load_factor_server] == 256 &&
3526 jv.isMember(jss::load_factor_fee_escalation) &&
3527 jv[jss::load_factor_fee_escalation] == 256 &&
3528 jv.isMember(jss::load_factor_fee_queue) && jv[jss::load_factor_fee_queue] == 256 &&
3529 jv.isMember(jss::load_factor_fee_reference) &&
3530 jv[jss::load_factor_fee_reference] == 256;
3533 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
3534 return jv[jss::type] ==
"serverStatus" && jv.isMember(jss::load_factor) &&
3535 jv[jss::load_factor] == 227555 && jv.isMember(jss::load_base) &&
3536 jv[jss::load_base] == 256 && jv.isMember(jss::load_factor_server) &&
3537 jv[jss::load_factor_server] == 256 &&
3538 jv.isMember(jss::load_factor_fee_escalation) &&
3539 jv[jss::load_factor_fee_escalation] == 227555 &&
3540 jv.isMember(jss::load_factor_fee_queue) && jv[jss::load_factor_fee_queue] == 256 &&
3541 jv.isMember(jss::load_factor_fee_reference) &&
3542 jv[jss::load_factor_fee_reference] == 256;
3548 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
3549 return jv[jss::type] ==
"serverStatus" && jv.isMember(jss::load_factor) &&
3550 jv[jss::load_factor] == 256 && jv.isMember(jss::load_base) &&
3551 jv[jss::load_base] == 256 && jv.isMember(jss::load_factor_server) &&
3552 jv[jss::load_factor_server] == 256 &&
3553 jv.isMember(jss::load_factor_fee_escalation) &&
3554 jv[jss::load_factor_fee_escalation] == 256 &&
3555 jv.isMember(jss::load_factor_fee_queue) && jv[jss::load_factor_fee_queue] == 256 &&
3556 jv.isMember(jss::load_factor_fee_reference) &&
3557 jv[jss::load_factor_fee_reference] == 256;
3567 env(
noop(a),
Fee(baseFee), queued);
3568 env(
noop(b),
Fee(baseFee), queued);
3569 env(
noop(c),
Fee(baseFee), queued);
3570 env(
noop(d),
Fee(baseFee), queued);
3571 env(
noop(e),
Fee(baseFee), queued);
3572 env(
noop(f),
Fee(baseFee), queued);
3573 env(
noop(g),
Fee(baseFee), queued);
3577 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
3578 return jv[jss::type] ==
"serverStatus" && jv.isMember(jss::load_factor) &&
3579 jv[jss::load_factor] == 200000 && jv.isMember(jss::load_base) &&
3580 jv[jss::load_base] == 256 && jv.isMember(jss::load_factor_server) &&
3581 jv[jss::load_factor_server] == 256 &&
3582 jv.isMember(jss::load_factor_fee_escalation) &&
3583 jv[jss::load_factor_fee_escalation] == 200000 &&
3584 jv.isMember(jss::load_factor_fee_queue) && jv[jss::load_factor_fee_queue] == 256 &&
3585 jv.isMember(jss::load_factor_fee_reference) &&
3586 jv[jss::load_factor_fee_reference] == 256;
3591 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
3592 return jv[jss::type] ==
"serverStatus" && jv.isMember(jss::load_factor) &&
3593 jv[jss::load_factor] == 184320 && jv.isMember(jss::load_base) &&
3594 jv[jss::load_base] == 256 && jv.isMember(jss::load_factor_server) &&
3595 jv[jss::load_factor_server] == 256 &&
3596 jv.isMember(jss::load_factor_fee_escalation) &&
3597 jv[jss::load_factor_fee_escalation] == 184320 &&
3598 jv.isMember(jss::load_factor_fee_queue) && jv[jss::load_factor_fee_queue] == 256 &&
3599 jv.isMember(jss::load_factor_fee_reference) &&
3600 jv[jss::load_factor_fee_reference] == 256;
3605 BEAST_EXPECT(wsc->findMsg(5s, [&](
auto const& jv) {
3606 return jv[jss::type] ==
"serverStatus" && jv.isMember(jss::load_factor) &&
3607 jv[jss::load_factor] == 256 && jv.isMember(jss::load_base) &&
3608 jv[jss::load_base] == 256 && jv.isMember(jss::load_factor_server) &&
3609 jv[jss::load_factor_server] == 256 &&
3610 jv.isMember(jss::load_factor_fee_escalation) &&
3611 jv[jss::load_factor_fee_escalation] == 256 &&
3612 jv.isMember(jss::load_factor_fee_queue) && jv[jss::load_factor_fee_queue] == 256 &&
3613 jv.isMember(jss::load_factor_fee_reference) &&
3614 jv[jss::load_factor_fee_reference] == 256;
3623 if (!wsc->findMsg(1s, [&](
auto const& jv) { return jv[jss::type] ==
"serverStatus"; }))
3629 auto jv = wsc->invoke(
"unsubscribe", stream);
3630 BEAST_EXPECT(jv[jss::status] ==
"success");
3636 using namespace jtx;
3640 auto const baseFee = env.
current()->fees().base.drops();
3641 auto const alice =
Account(
"alice");
3642 auto const bob =
Account(
"bob");
3645 env.fund(
XRP(50000000), alice, bob);
3649 auto const calcTotalFee = [&](
std::int64_t alreadyPaid,
3652 auto totalFactor = 0;
3653 auto const metrics = env.app().getTxQ().getMetrics(*env.current());
3655 numToClear.emplace(
metrics.txCount + 1);
3656 for (
int i = 0; i < *numToClear; ++i)
3658 auto const inLedger =
metrics.txInLedger + i;
3659 totalFactor += inLedger * inLedger;
3666 auto result =
toDrops(feeLevel, env.current()->fees().base).
drops();
3669 result -= alreadyPaid;
3675 testcase(
"straightforward positive case");
3678 auto aliceSeq = env.seq(alice);
3680 for (
int i = 0; i < 2; ++i)
3683 totalPaid += baseFee * 10;
3708 totalPaid += totalFee;
3709 totalFee = calcTotalFee(totalPaid);
3712 env(
noop(alice),
Fee(totalFee),
Seq(aliceSeq++));
3717 testcase(
"replace last tx with enough to clear queue");
3720 auto aliceSeq = env.seq(alice);
3722 for (
int i = 0; i < 2; ++i)
3725 totalPaid += baseFee * 10;
3737 auto const metrics = env.app().getTxQ().getMetrics(*env.current());
3741 env(
noop(alice),
Fee(totalFee),
Seq(aliceSeq++));
3750 testcase(
"replace middle tx with enough to clear queue");
3754 auto aliceSeq = env.seq(alice);
3755 for (
int i = 0; i < 5; ++i)
3763 uint64_t const totalFee = calcTotalFee(baseFee * 10 * 2, 3);
3766 env(
noop(alice),
Fee(totalFee),
Seq(aliceSeq++));
3769 auto const aliceQueue = env.app().getTxQ().getAccountTxs(alice.id());
3770 BEAST_EXPECT(aliceQueue.size() == 2);
3772 for (
auto const& tx : aliceQueue)
3774 BEAST_EXPECT(tx.seqProxy == seq);
3775 BEAST_EXPECT(tx.feeLevel ==
FeeLevel64{kBaseFeeLevel.fee() * 10});
3784 testcase(
"clear queue failure (load)");
3788 auto aliceSeq = env.seq(alice);
3790 for (
int i = 0; i < 2; ++i)
3793 totalPaid += baseFee * 20;
3795 for (
int i = 0; i < 2; ++i)
3798 totalPaid += baseFee * 2.2;
3807 auto& feeTrack = env.app().getFeeTrack();
3808 auto const origFee = feeTrack.getRemoteFee();
3809 feeTrack.setRemoteFee(origFee * 5);
3822 feeTrack.setRemoteFee(origFee);
3841 using namespace jtx;
3842 using namespace std::chrono_literals;
3855 auto const alice =
Account(
"alice");
3858 env.fund(
XRP(50000000), alice);
3862 auto seqAlice = env.seq(alice);
3864 for (
int i = 0; i < txCount; ++i)
3908 env.close(env.now() + 5s, 10000ms);
3913 env.close(env.now() + 5s, 10000ms);
3918 env.close(env.now() + 5s, 10000ms);
3925 env.close(env.now() + 5s, 10000ms);
3929 BEAST_EXPECT(!txCount);
3942 auto const alice =
Account(
"alice");
3945 env.fund(
XRP(50000000), alice);
3949 auto seqAlice = env.seq(alice);
3951 for (
int i = 0; i < txCount; ++i)
3970 env.close(env.now() + 5s, 10000ms);
3976 BEAST_EXPECT(!txCount);
4147 using namespace jtx;
4156 static constexpr int kLedgersInQueue = 30;
4171 Env env(*
this, std::move(cfg));
4191 for (i = 0; i <= 257; ++i)
4198 checkMetrics(*
this, env, 0, kLedgersInQueue * expectedPerLedger, 0, expectedPerLedger);
4203 using namespace std::chrono_literals;
4204 auto const closeDuration = 80
min;
4205 for (i = 0; i <= 255; ++i)
4207 env.
close(closeDuration);
4210 auto const baseFee = env.
current()->fees().base.drops();
4217 kLedgersInQueue * expectedPerLedger,
4218 expectedPerLedger + 1,
4222 auto seqAlice = env.
seq(alice);
4223 auto seqBob = env.
seq(bob);
4224 auto seqCarol = env.
seq(carol);
4225 auto seqDaria = env.
seq(daria);
4226 auto seqEllie = env.
seq(ellie);
4227 auto seqFiona = env.
seq(fiona);
4230 int txFee{
static_cast<int>(baseFee * 9)};
4231 auto const prepareFee = [&](
uint64_t multiplier) {
4232 return Fee(
txFee - (multiplier * baseFee / 10));
4236 for (
int i = 0; i < 10; ++i)
4250 kLedgersInQueue * expectedPerLedger,
4251 expectedPerLedger + 1,
4265 env.
close(closeDuration);
4266 auto expectedInLedger = expectedInQueue;
4268 (expectedInQueue > expectedPerLedger + 2 ? expectedInQueue - (expectedPerLedger + 2)
4270 expectedInLedger -= expectedInQueue;
4271 ++expectedPerLedger;
4276 kLedgersInQueue * expectedPerLedger,
4280 auto const expectedPerAccount = expectedInQueue / 6;
4281 auto const expectedRemainder = expectedInQueue % 6;
4282 BEAST_EXPECT(env.
seq(alice) == seqAlice - expectedPerAccount);
4284 env.
seq(bob) == seqBob - expectedPerAccount - (expectedRemainder > 4 ? 1 : 0));
4287 seqCarol - expectedPerAccount - (expectedRemainder > 3 ? 1 : 0));
4290 seqDaria - expectedPerAccount - (expectedRemainder > 2 ? 1 : 0));
4293 seqEllie - expectedPerAccount - (expectedRemainder > 1 ? 1 : 0));
4296 seqFiona - expectedPerAccount - (expectedRemainder > 0 ? 1 : 0));
4298 }
while (expectedInQueue > 0);
4642 using namespace jtx;
4660 auto const initQueueMax =
initFee(env, 3, 2, 0, 0, 0);
4662 BEAST_EXPECT(env.current()->fees().base == 0);
4665 auto const fee = env.rpc(
"fee");
4667 if (BEAST_EXPECT(fee.isMember(jss::result)) &&
4670 auto const& result = fee[jss::result];
4672 BEAST_EXPECT(result.isMember(jss::levels));
4673 auto const& levels = result[jss::levels];
4675 levels.isMember(jss::median_level) && levels[jss::median_level] ==
"128000");
4677 levels.isMember(jss::minimum_level) && levels[jss::minimum_level] ==
"256");
4679 levels.isMember(jss::open_ledger_level) &&
4680 levels[jss::open_ledger_level] ==
"256");
4682 levels.isMember(jss::reference_level) && levels[jss::reference_level] ==
"256");
4684 auto const&
drops = result[jss::drops];
4685 BEAST_EXPECT(
drops.isMember(jss::base_fee) &&
drops[jss::base_fee] ==
"0");
4686 BEAST_EXPECT(
drops.isMember(jss::median_fee) &&
drops[jss::median_fee] ==
"0");
4687 BEAST_EXPECT(
drops.isMember(jss::minimum_fee) &&
drops[jss::minimum_fee] ==
"0");
4689 drops.isMember(jss::open_ledger_fee) &&
drops[jss::open_ledger_fee] ==
"0");
4713 auto aliceSeq = env.seq(alice);
4714 env(
noop(alice), queued);
4718 env(
noop(alice),
Seq(aliceSeq + 1),
Fee(10), queued);
4723 auto const fee = env.rpc(
"fee");
4725 if (BEAST_EXPECT(fee.isMember(jss::result)) &&
4728 auto const& result = fee[jss::result];
4730 BEAST_EXPECT(result.isMember(jss::levels));
4731 auto const& levels = result[jss::levels];
4733 levels.isMember(jss::median_level) && levels[jss::median_level] ==
"128000");
4735 levels.isMember(jss::minimum_level) && levels[jss::minimum_level] ==
"256");
4737 levels.isMember(jss::open_ledger_level) &&
4738 levels[jss::open_ledger_level] ==
"355555");
4740 levels.isMember(jss::reference_level) && levels[jss::reference_level] ==
"256");
4742 auto const&
drops = result[jss::drops];
4743 BEAST_EXPECT(
drops.isMember(jss::base_fee) &&
drops[jss::base_fee] ==
"0");
4744 BEAST_EXPECT(
drops.isMember(jss::median_fee) &&
drops[jss::median_fee] ==
"0");
4745 BEAST_EXPECT(
drops.isMember(jss::minimum_fee) &&
drops[jss::minimum_fee] ==
"0");
4747 drops.isMember(jss::open_ledger_fee) &&
drops[jss::open_ledger_fee] ==
"1389");