xrpld
Loading...
Searching...
No Matches
FeeVote_test.cpp
1
2#include <test/jtx/Env.h>
3
4#include <xrpld/app/misc/FeeVote.h>
5#include <xrpld/core/Config.h>
6
7#include <xrpl/basics/base_uint.h>
8#include <xrpl/beast/hash/uhash.h>
9#include <xrpl/beast/unit_test/suite.h>
10#include <xrpl/config/BasicConfig.h>
11#include <xrpl/ledger/ApplyView.h>
12#include <xrpl/ledger/Ledger.h>
13#include <xrpl/ledger/OpenView.h>
14#include <xrpl/protocol/Feature.h>
15#include <xrpl/protocol/Fees.h>
16#include <xrpl/protocol/Indexes.h>
17#include <xrpl/protocol/KeyType.h>
18#include <xrpl/protocol/PublicKey.h>
19#include <xrpl/protocol/Rules.h>
20#include <xrpl/protocol/SField.h>
21#include <xrpl/protocol/STTx.h>
22#include <xrpl/protocol/STValidation.h>
23#include <xrpl/protocol/SecretKey.h>
24#include <xrpl/protocol/Serializer.h>
25#include <xrpl/protocol/TER.h>
26#include <xrpl/protocol/TxFormats.h>
27#include <xrpl/protocol/XRPAmount.h>
28#include <xrpl/shamap/SHAMap.h>
29#include <xrpl/shamap/SHAMapMissingNode.h>
30#include <xrpl/tx/apply.h>
31
32#include <cstdint>
33#include <functional>
34#include <limits>
35#include <memory>
36#include <optional>
37#include <source_location>
38#include <string>
39#include <unordered_set>
40#include <utility>
41#include <vector>
42
43namespace xrpl::test {
44
54
55STTx
57 Rules const& rules,
58 std::uint32_t seq,
59 FeeSettingsFields const& fields,
60 bool forceAllFields = false)
61{
62 auto const fill = [&](auto& obj) {
63 obj.setAccountID(sfAccount, AccountID());
64 obj.setFieldU32(sfLedgerSequence, seq);
65
66 // XRPFees feature has been retired - all three fields are REQUIRED
67 obj.setFieldAmount(
68 sfBaseFeeDrops, fields.baseFeeDrops ? *fields.baseFeeDrops : XRPAmount{0});
69 obj.setFieldAmount(
70 sfReserveBaseDrops, fields.reserveBaseDrops ? *fields.reserveBaseDrops : XRPAmount{0});
71 obj.setFieldAmount(
72 sfReserveIncrementDrops,
74 if (rules.enabled(featureSmartEscrow) || forceAllFields)
75 {
76 obj.setFieldU32(sfGasLimit, fields.gasLimit ? *fields.gasLimit : 0);
77 obj.setFieldU32(
78 sfBytecodeSizeLimit, fields.bytecodeSizeLimit ? *fields.bytecodeSizeLimit : 0);
79 obj.setFieldU32(sfGasPrice, fields.gasPrice ? *fields.gasPrice : 0);
80 }
81 };
82 return STTx(ttFEE, fill);
83}
84
85// A ttFEE transaction that omits the (now mandatory) *Drops fields.
86STTx
88{
89 return STTx(ttFEE, [&](auto& obj) {
90 obj.setAccountID(sfAccount, AccountID());
91 obj.setFieldU32(sfLedgerSequence, seq);
92 });
93}
94
95// A ttFEE transaction that carries all the required *Drops fields, but also
96// the pre-XRPFees legacy fields, which are forbidden now that XRPFees has
97// been retired.
98STTx
100{
101 return STTx(ttFEE, [&](auto& obj) {
102 obj.setAccountID(sfAccount, AccountID());
103 obj.setFieldU32(sfLedgerSequence, seq);
104
105 obj.setFieldAmount(sfBaseFeeDrops, XRPAmount{10});
106 obj.setFieldAmount(sfReserveBaseDrops, XRPAmount{200000});
107 obj.setFieldAmount(sfReserveIncrementDrops, XRPAmount{50000});
108
109 obj.setFieldU64(sfBaseFee, 10);
110 obj.setFieldU32(sfReserveBase, 200000);
111 obj.setFieldU32(sfReserveIncrement, 50000);
112 obj.setFieldU32(sfReferenceFeeUnits, 10);
113 });
114}
115
116TER
118{
119 auto const res = apply(env.app(), view, tx, ApplyFlags::TapNone, env.journal);
120 return res.ter;
121}
122
123bool
125 std::shared_ptr<Ledger const> const& ledger,
126 Rules const& rules,
127 FeeSettingsFields const& expected)
128{
129 auto const feeObject = ledger->read(keylet::feeSettings());
130 if (!feeObject)
131 return false;
132
133 auto const checkEquality = [&](auto const& field, auto const& expected) {
134 if (!feeObject->isFieldPresent(field))
135 return false;
136 return feeObject->at(field) == expected;
137 };
138
139 if (feeObject->isFieldPresent(sfBaseFee) || feeObject->isFieldPresent(sfReserveBase) ||
140 feeObject->isFieldPresent(sfReserveIncrement) ||
141 feeObject->isFieldPresent(sfReferenceFeeUnits))
142 return false;
143
144 if (!checkEquality(sfBaseFeeDrops, expected.baseFeeDrops.value_or(XRPAmount{0})))
145 return false;
146 if (!checkEquality(sfReserveBaseDrops, expected.reserveBaseDrops.value_or(XRPAmount{0})))
147 return false;
148 if (!checkEquality(
149 sfReserveIncrementDrops, expected.reserveIncrementDrops.value_or(XRPAmount{0})))
150 return false;
151 if (rules.enabled(featureSmartEscrow))
152 {
153 if (!checkEquality(sfGasLimit, expected.gasLimit.value_or(0)))
154 return false;
155 if (!checkEquality(sfBytecodeSizeLimit, expected.bytecodeSizeLimit.value_or(0)))
156 return false;
157 if (!checkEquality(sfGasPrice, expected.gasPrice.value_or(0)))
158 return false;
159 }
160 else
161 {
162 if (feeObject->isFieldPresent(sfGasLimit) ||
163 feeObject->isFieldPresent(sfBytecodeSizeLimit) || feeObject->isFieldPresent(sfGasPrice))
164 return false;
165 }
166
167 return true;
168}
169
172{
174 for (auto i = txSet->begin(); i != txSet->end(); ++i)
175 {
176 auto const data = i->slice();
177 auto serialIter = SerialIter(data);
178 txs.emplace_back(serialIter);
179 }
180 return txs;
181};
182
184{
185 void
187 {
188 testcase("FeeVote setup");
189 FeeSetup const defaultSetup;
190 {
191 // defaults
192 Section const config;
193 auto const setup = setupFeeVote(config);
194 BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee);
195 BEAST_EXPECT(setup.accountReserve == defaultSetup.accountReserve);
196 BEAST_EXPECT(setup.ownerReserve == defaultSetup.ownerReserve);
197 BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
198 BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
199 BEAST_EXPECT(setup.gasPrice == defaultSetup.gasPrice);
200 }
201 {
202 Section config;
203 config.append({
204 "reference_fee = 50",
205 "account_reserve = 1234567",
206 "owner_reserve = 1234",
207 "gas_limit = 100",
208 "bytecode_size_limit = 200",
209 "gas_price = 300",
210 });
211 auto const setup = setupFeeVote(config);
212 BEAST_EXPECT(setup.referenceFee == 50);
213 BEAST_EXPECT(setup.accountReserve == 1234567);
214 BEAST_EXPECT(setup.ownerReserve == 1234);
215 BEAST_EXPECT(setup.gasLimit == 100);
216 BEAST_EXPECT(setup.bytecodeSizeLimit == 200);
217 BEAST_EXPECT(setup.gasPrice == 300);
218 }
219 {
220 Section config;
221 config.append({
222 "reference_fee = blah",
223 "account_reserve = yada",
224 "owner_reserve = foo",
225 "gas_limit = bar",
226 "bytecode_size_limit = baz",
227 "gas_price = qux",
228 });
229 // Illegal values are ignored, and the defaults left unchanged
230 auto const setup = setupFeeVote(config);
231 BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee);
232 BEAST_EXPECT(setup.accountReserve == defaultSetup.accountReserve);
233 BEAST_EXPECT(setup.ownerReserve == defaultSetup.ownerReserve);
234 BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
235 BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
236 BEAST_EXPECT(setup.gasPrice == defaultSetup.gasPrice);
237 }
238 {
239 Section config;
240 config.append({
241 "reference_fee = -50",
242 "account_reserve = -1234567",
243 "owner_reserve = -1234",
244 "gas_limit = -100",
245 "bytecode_size_limit = -200",
246 "gas_price = -300",
247 });
248 // Negative gas settings are ignored. The reserves keep their
249 // existing wrapping behavior.
250 auto const setup = setupFeeVote(config);
251 BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee);
252 BEAST_EXPECT(setup.accountReserve == static_cast<std::uint32_t>(-1234567));
253 BEAST_EXPECT(setup.ownerReserve == static_cast<std::uint32_t>(-1234));
254 BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
255 BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
256 BEAST_EXPECT(setup.gasPrice == defaultSetup.gasPrice);
257 }
258 {
259 auto const big64 = std::to_string(
261 Section config;
262 config.append({
263 "reference_fee = " + big64,
264 "account_reserve = " + big64,
265 "owner_reserve = " + big64,
266 "gas_limit = " + big64,
267 "bytecode_size_limit = " + big64,
268 "gas_price = " + big64,
269 });
270 // Illegal values are ignored, and the defaults left unchanged
271 auto const setup = setupFeeVote(config);
272 BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee);
273 BEAST_EXPECT(setup.accountReserve == defaultSetup.accountReserve);
274 BEAST_EXPECT(setup.ownerReserve == defaultSetup.ownerReserve);
275 BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
276 BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
277 BEAST_EXPECT(setup.gasPrice == defaultSetup.gasPrice);
278 }
279 {
280 Section config;
281 config.append({
282 "gas_limit = " + std::to_string(kMaxGasLimit + 1),
283 "bytecode_size_limit = " + std::to_string(kMaxBytecodeSizeLimit + 1),
284 });
285 auto const setup = setupFeeVote(config);
286 BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
287 BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
288 }
289 {
290 Section config;
291 config.append({
292 "gas_limit = " + std::to_string(kMaxGasLimit),
293 "bytecode_size_limit = " + std::to_string(kMaxBytecodeSizeLimit),
294 });
295 auto const setup = setupFeeVote(config);
296 BEAST_EXPECT(setup.gasLimit == kMaxGasLimit);
297 BEAST_EXPECT(setup.bytecodeSizeLimit == kMaxBytecodeSizeLimit);
298 }
299 {
300 // Zero is below kMinGasPrice, so the default is kept.
301 Section config;
302 config.append("gas_price = 0");
303 auto const setup = setupFeeVote(config);
304 BEAST_EXPECT(setup.gasPrice == defaultSetup.gasPrice);
305 }
306 {
307 // The floor is inclusive: a configured price of 1 is accepted.
308 Section config;
309 config.append({"gas_price = " + std::to_string(kMinGasPrice)});
310 auto const setup = setupFeeVote(config);
311 BEAST_EXPECT(setup.gasPrice == kMinGasPrice);
312 }
313 }
314
315 void
317 {
318 testcase("Basic SetFee transaction");
319
320 // Test without SmartEscrow
321 {
322 jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
323 auto ledger = std::make_shared<Ledger>(
325 Rules{env.app().config().features},
326 env.app().config().fees.toFees(),
328 env.app().getNodeFamily());
329
330 // Create the next ledger to apply transaction to
331 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
332
333 FeeSettingsFields const fields{
334 .baseFeeDrops = XRPAmount{10},
335 .reserveBaseDrops = XRPAmount{200000},
336 .reserveIncrementDrops = XRPAmount{50000},
337 };
338 // Test successful fee transaction with new fields
339 auto const feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
340
341 OpenView accum(ledger.get());
342 BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
343 accum.apply(*ledger);
344
345 // Verify fee object was created/updated correctly
346 BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields));
347 }
348
349 // Test with SmartEscrow enabled
350 {
351 jtx::Env env(*this, jtx::testableAmendments());
352 auto ledger = std::make_shared<Ledger>(
354 Rules{env.app().config().features},
355 env.app().config().fees.toFees(),
357 env.app().getNodeFamily());
358
359 // Create the next ledger to apply transaction to
360 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
361
362 FeeSettingsFields const fields{
363 .baseFeeDrops = XRPAmount{10},
364 .reserveBaseDrops = XRPAmount{200000},
365 .reserveIncrementDrops = XRPAmount{50000},
366 .gasLimit = 100,
367 .bytecodeSizeLimit = 200,
368 .gasPrice = 300,
369 };
370 // Test successful fee transaction with new fields
371 auto const feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
372
373 OpenView accum(ledger.get());
374 BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
375 accum.apply(*ledger);
376
377 // Verify fee object was created/updated correctly
378 BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields));
379 }
380
381 // Test that Smart Escrow limits reject values outside their bounds.
382 {
383 jtx::Env env(*this, jtx::testableAmendments());
384 auto ledger = std::make_shared<Ledger>(
386 Rules{env.app().config().features},
387 env.app().config().fees.toFees(),
389 env.app().getNodeFamily());
390
391 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
392
393 auto const testBadFields = [&](FeeSettingsFields const& fields) {
394 auto const feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
395 OpenView accum(ledger.get());
396 BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
397 };
398
399 testBadFields({
400 .baseFeeDrops = XRPAmount{10},
401 .reserveBaseDrops = XRPAmount{200000},
402 .reserveIncrementDrops = XRPAmount{50000},
403 .gasLimit = kMaxGasLimit + 1,
404 .bytecodeSizeLimit = kMaxBytecodeSizeLimit,
405 .gasPrice = 300,
406 });
407 testBadFields({
408 .baseFeeDrops = XRPAmount{10},
409 .reserveBaseDrops = XRPAmount{200000},
410 .reserveIncrementDrops = XRPAmount{50000},
411 .gasLimit = kMaxGasLimit,
412 .bytecodeSizeLimit = kMaxBytecodeSizeLimit + 1,
413 .gasPrice = 300,
414 });
415 // gasPrice == 0 is temBAD_FEE; gasLimit == 0 remains a valid kill
416 // switch.
417 testBadFields({
418 .baseFeeDrops = XRPAmount{10},
419 .reserveBaseDrops = XRPAmount{200000},
420 .reserveIncrementDrops = XRPAmount{50000},
421 .gasLimit = kMaxGasLimit,
422 .bytecodeSizeLimit = kMaxBytecodeSizeLimit,
423 .gasPrice = 0,
424 });
425 }
426
427 // ttFEE at exactly kMinGasPrice applies and is stored.
428 {
429 jtx::Env env(*this, jtx::testableAmendments());
430 auto ledger = std::make_shared<Ledger>(
432 Rules{env.app().config().features},
433 env.app().config().fees.toFees(),
435 env.app().getNodeFamily());
436
437 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
438
439 FeeSettingsFields const fields{
440 .baseFeeDrops = XRPAmount{10},
441 .reserveBaseDrops = XRPAmount{200000},
442 .reserveIncrementDrops = XRPAmount{50000},
443 .gasLimit = 100,
444 .bytecodeSizeLimit = 200,
445 .gasPrice = kMinGasPrice,
446 };
447 auto const feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
448
449 OpenView accum(ledger.get());
450 BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
451 accum.apply(*ledger);
452
453 BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields));
454 }
455
456 // Test that the Smart Escrow fields are rejected if the
457 // feature is disabled
458 {
459 jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
460 auto ledger = std::make_shared<Ledger>(
462 Rules{env.app().config().features},
463 env.app().config().fees.toFees(),
465 env.app().getNodeFamily());
466
467 // Create the next ledger to apply transaction to
468 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
469
470 FeeSettingsFields const fields{
471 .baseFeeDrops = XRPAmount{10},
472 .reserveBaseDrops = XRPAmount{200000},
473 .reserveIncrementDrops = XRPAmount{50000},
474 .gasLimit = 100,
475 .bytecodeSizeLimit = 200,
476 .gasPrice = 300,
477 };
478 // Test successful fee transaction with new fields
479 auto const feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields, true);
480
481 OpenView accum(ledger.get());
482 BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
483 }
484 }
485
486 void
488 {
489 testcase("Fee Transaction Validation");
490
491 {
492 jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
493 auto ledger = std::make_shared<Ledger>(
495 Rules{env.app().config().features},
496 env.app().config().fees.toFees(),
498 env.app().getNodeFamily());
499
500 // Create the next ledger to apply transaction to
501 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
502
503 OpenView accum(ledger.get());
504
505 // Test transaction with missing required new fields
506 auto const missingTx = createFeeTxMissingRequiredFields(ledger->seq());
507 BEAST_EXPECT(applyFeeAndTestResult(env, accum, missingTx) == temMALFORMED);
508
509 // Test transaction that has all the required fields but also carries
510 // the legacy fields. Now that XRPFees is retired those are forbidden,
511 // and rejected with temMALFORMED rather than the former temDISABLED.
512 auto const disallowedTx = createFeeTxWithLegacyFields(ledger->seq());
513 BEAST_EXPECT(applyFeeAndTestResult(env, accum, disallowedTx) == temMALFORMED);
514
515 Serializer s;
516 disallowedTx.add(s);
517 SerialIter sit(s.slice());
518 STTx const parsedTx(sit);
519 BEAST_EXPECT(parsedTx.getFieldU64(sfBaseFee) == 10);
520 BEAST_EXPECT(parsedTx.getFieldU32(sfReferenceFeeUnits) == 10);
521 BEAST_EXPECT(parsedTx.getFieldU32(sfReserveBase) == 200000);
522 BEAST_EXPECT(parsedTx.getFieldU32(sfReserveIncrement) == 50000);
523 }
524
525 {
526 jtx::Env env(*this, jtx::testableAmendments());
527 auto ledger = std::make_shared<Ledger>(
529 Rules{env.app().config().features},
530 env.app().config().fees.toFees(),
532 env.app().getNodeFamily());
533
534 // Create the next ledger to apply transaction to
535 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
536
537 OpenView accum(ledger.get());
538
539 // Test transaction with missing required new fields
540 auto const missingTx = createFeeTxMissingRequiredFields(ledger->seq());
541 BEAST_EXPECT(applyFeeAndTestResult(env, accum, missingTx) == temMALFORMED);
542
543 // Test transaction with legacy fields
544 auto const disallowedTx = createFeeTxWithLegacyFields(ledger->seq());
545 BEAST_EXPECT(applyFeeAndTestResult(env, accum, disallowedTx) == temMALFORMED);
546
547 // Valid XRP fee fields, but none of the gas fields
548 STTx const noGasTx(ttFEE, [&](auto& obj) {
549 obj.setAccountID(sfAccount, AccountID());
550 obj.setFieldU32(sfLedgerSequence, ledger->seq());
551 obj.setFieldAmount(sfBaseFeeDrops, XRPAmount{10});
552 obj.setFieldAmount(sfReserveBaseDrops, XRPAmount{200000});
553 obj.setFieldAmount(sfReserveIncrementDrops, XRPAmount{50000});
554 });
555 BEAST_EXPECT(applyFeeAndTestResult(env, accum, noGasTx) == temMALFORMED);
556 }
557 }
558
559 void
561 {
562 testcase("Pseudo Transaction Properties");
563
564 jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
565 auto ledger = std::make_shared<Ledger>(
567 Rules{env.app().config().features},
568 env.app().config().fees.toFees(),
570 env.app().getNodeFamily());
571
572 // Create the next ledger to apply transaction to
573 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
574
575 auto const feeTx = createFeeTx(
576 ledger->rules(),
577 ledger->seq(),
578 {
579 .baseFeeDrops = XRPAmount{10},
580 .reserveBaseDrops = XRPAmount{200000},
581 .reserveIncrementDrops = XRPAmount{50000},
582 });
583
584 // Verify pseudo-transaction properties
585 BEAST_EXPECT(feeTx.getAccountID(sfAccount) == AccountID());
586 BEAST_EXPECT(feeTx.getFieldAmount(sfFee) == XRPAmount{0});
587 BEAST_EXPECT(feeTx.getSigningPubKey().empty());
588 BEAST_EXPECT(feeTx.getSignature().empty());
589 BEAST_EXPECT(!feeTx.isFieldPresent(sfSigners));
590 BEAST_EXPECT(feeTx.getFieldU32(sfSequence) == 0);
591 BEAST_EXPECT(!feeTx.isFieldPresent(sfPreviousTxnID));
592
593 // But can be applied to a closed ledger
594 {
595 OpenView closedAccum(ledger.get());
596 BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, closedAccum, feeTx)));
597 }
598 }
599
600 void
602 {
603 testcase("Multiple Fee Updates");
604
605 jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
606 auto ledger = std::make_shared<Ledger>(
608 Rules{env.app().config().features},
609 env.app().config().fees.toFees(),
611 env.app().getNodeFamily());
612
613 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
614
615 FeeSettingsFields const fields1{
616 .baseFeeDrops = XRPAmount{10},
617 .reserveBaseDrops = XRPAmount{200000},
618 .reserveIncrementDrops = XRPAmount{50000},
619 };
620 auto const feeTx1 = createFeeTx(ledger->rules(), ledger->seq(), fields1);
621
622 {
623 OpenView accum(ledger.get());
624 BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx1)));
625 accum.apply(*ledger);
626 }
627
628 BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields1));
629
630 // Apply second fee transaction with different values
631 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
632
633 FeeSettingsFields const fields2{
634 .baseFeeDrops = XRPAmount{20},
635 .reserveBaseDrops = XRPAmount{300000},
636 .reserveIncrementDrops = XRPAmount{75000},
637 };
638 auto const feeTx2 = createFeeTx(ledger->rules(), ledger->seq(), fields2);
639
640 {
641 OpenView accum(ledger.get());
642 BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx2)));
643 accum.apply(*ledger);
644 }
645
646 // Verify second update overwrote the first
647 BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields2));
648 }
649
650 void
652 {
653 testcase("Wrong Ledger Sequence");
654
655 jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
656 auto ledger = std::make_shared<Ledger>(
658 Rules{env.app().config().features},
659 env.app().config().fees.toFees(),
661 env.app().getNodeFamily());
662
663 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
664
665 // Test transaction with wrong ledger sequence
666 auto const feeTx = createFeeTx(
667 ledger->rules(),
668 ledger->seq() + 5, // Wrong sequence (should be ledger->seq())
669 {
670 .baseFeeDrops = XRPAmount{10},
671 .reserveBaseDrops = XRPAmount{200000},
672 .reserveIncrementDrops = XRPAmount{50000},
673 });
674
675 OpenView accum(ledger.get());
676
677 // The transaction should still succeed as long as other fields are
678 // valid
679 // The ledger sequence field is only used for informational purposes
680 BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
681 }
682
683 void
685 {
686 testcase("Partial Field Updates");
687
688 jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
689 auto ledger = std::make_shared<Ledger>(
691 Rules{env.app().config().features},
692 env.app().config().fees.toFees(),
694 env.app().getNodeFamily());
695
696 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
697
698 FeeSettingsFields const fields1{
699 .baseFeeDrops = XRPAmount{10},
700 .reserveBaseDrops = XRPAmount{200000},
701 .reserveIncrementDrops = XRPAmount{50000},
702 };
703 auto const feeTx1 = createFeeTx(ledger->rules(), ledger->seq(), fields1);
704
705 {
706 OpenView accum(ledger.get());
707 BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx1)));
708 accum.apply(*ledger);
709 }
710
711 BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields1));
712
713 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
714
715 // Apply partial update (only some fields)
716 FeeSettingsFields const fields2{
717 .baseFeeDrops = XRPAmount{20},
718 .reserveBaseDrops = XRPAmount{200000},
719 };
720 auto const feeTx2 = createFeeTx(ledger->rules(), ledger->seq(), fields2);
721
722 {
723 OpenView accum(ledger.get());
724 BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx2)));
725 accum.apply(*ledger);
726 }
727
728 // Verify the partial update worked
729 BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields2));
730 }
731
732 void
734 {
735 testcase("Single Invalid Transaction");
736
737 jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
738 auto ledger = std::make_shared<Ledger>(
740 Rules{env.app().config().features},
741 env.app().config().fees.toFees(),
743 env.app().getNodeFamily());
744
745 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
746
747 // Test invalid transaction with non-zero account - this should fail
748 // validation
749 auto const invalidTx = STTx(ttFEE, [&](auto& obj) {
750 obj.setAccountID(sfAccount,
751 AccountID(1)); // Should be zero (this makes it invalid)
752 obj.setFieldU32(sfLedgerSequence, ledger->seq());
753 obj.setFieldAmount(sfBaseFeeDrops, XRPAmount{10});
754 obj.setFieldAmount(sfReserveBaseDrops, XRPAmount{200000});
755 obj.setFieldAmount(sfReserveIncrementDrops, XRPAmount{50000});
756 });
757
758 OpenView accum(ledger.get());
759 BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, invalidTx)));
760 }
761
762 void
764 {
765 testcase("doValidation");
766
767 using namespace jtx;
768
769 FeeSetup setup;
770 setup.referenceFee = 42;
771 setup.accountReserve = 1234567;
772 setup.ownerReserve = 7654321;
773
774 // Test without SmartEscrow
775 {
776 Env env(*this, testableAmendments() - featureSmartEscrow);
777 auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote"));
778
779 auto const ledger = std::make_shared<Ledger>(
781 Rules{env.app().config().features},
782 env.app().config().fees.toFees(),
784 env.app().getNodeFamily());
785
786 auto const sec = randomSecretKey();
787 auto const pub = derivePublicKey(KeyType::Secp256k1, sec);
788
789 auto const val = std::make_shared<STValidation>(
790 env.app().getTimeKeeper().now(), pub, sec, calcNodeID(pub), [](STValidation& v) {
791 v.setFieldU32(sfLedgerSequence, 12345);
792 });
793
794 // Use the current ledger's fees as the "current" fees for
795 // doValidation
796 auto const& currentFees = ledger->fees();
797
798 feeVote->doValidation(currentFees, ledger->rules(), *val);
799
800 BEAST_EXPECT(val->isFieldPresent(sfBaseFeeDrops));
801 BEAST_EXPECT(val->getFieldAmount(sfBaseFeeDrops) == XRPAmount(setup.referenceFee));
802 }
803
804 // A local target of 0 is not emitted on the validation; the field is
805 // omitted so peers treat it as noVote.
806 {
807 Env env(*this, testableAmendments());
808 FeeSetup zeroPrice = setup;
809 zeroPrice.gasPrice = 0;
810 auto feeVote = makeFeeVote(zeroPrice, env.app().getJournal("FeeVote"));
811
812 auto const ledger = std::make_shared<Ledger>(
814 Rules{env.app().config().features},
815 env.app().config().fees.toFees(),
817 env.app().getNodeFamily());
818
819 auto const sec = randomSecretKey();
820 auto const pub = derivePublicKey(KeyType::Secp256k1, sec);
821
822 auto const val = std::make_shared<STValidation>(
823 env.app().getTimeKeeper().now(), pub, sec, calcNodeID(pub), [](STValidation& v) {
824 v.setFieldU32(sfLedgerSequence, 12345);
825 });
826
827 feeVote->doValidation(ledger->fees(), ledger->rules(), *val);
828
829 BEAST_EXPECT(!val->isFieldPresent(sfGasPrice));
830 }
831 }
832
833 void
835 {
836 testcase("doVoting");
837
838 using namespace jtx;
839
840 FeeSetup setup;
841 setup.referenceFee = 42;
842 setup.accountReserve = 1234567;
843 setup.ownerReserve = 7654321;
844
845 Env env(*this, testableAmendments() - featureSmartEscrow);
846
847 // establish what the current fees are
848 BEAST_EXPECT(env.current()->fees().base == XRPAmount{UNIT_TEST_REFERENCE_FEE});
849 BEAST_EXPECT(env.current()->fees().reserve == XRPAmount{200'000'000});
850 BEAST_EXPECT(env.current()->fees().increment == XRPAmount{50'000'000});
851
852 auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote"));
853 auto ledger = std::make_shared<Ledger>(
855 Rules{env.app().config().features},
856 env.app().config().fees.toFees(),
858 env.app().getNodeFamily());
859
860 // doVoting requires a flag ledger (every 256th ledger)
861 // We need to create a ledger at sequence 256 to make it a flag ledger
862 for (int i = 0; i < 256 - 1; ++i)
863 {
864 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
865 }
866 BEAST_EXPECT(ledger->isFlagLedger());
867
868 // Create some mock validations with fee votes
870
871 for (int i = 0; i < 5; i++)
872 {
873 auto const sec = randomSecretKey();
874 auto const pub = derivePublicKey(KeyType::Secp256k1, sec);
875
876 auto const val = std::make_shared<STValidation>(
877 env.app().getTimeKeeper().now(), pub, sec, calcNodeID(pub), [&](STValidation& v) {
878 v.setFieldU32(sfLedgerSequence, ledger->seq());
879 // Vote for different fees than current
880 v.setFieldAmount(sfBaseFeeDrops, XRPAmount{setup.referenceFee});
881 v.setFieldAmount(sfReserveBaseDrops, XRPAmount{setup.accountReserve});
882 v.setFieldAmount(sfReserveIncrementDrops, XRPAmount{setup.ownerReserve});
883 });
884 if ((i % 2) != 0)
885 val->setTrusted();
886 validations.push_back(val);
887 }
888
889 auto const txSet =
891
892 // This should not throw since we have a flag ledger
893 feeVote->doVoting(ledger, validations, txSet);
894
895 auto const txs = getTxs(txSet);
896 BEAST_EXPECT(txs.size() == 1);
897 auto const& feeTx = txs[0];
898
899 BEAST_EXPECT(feeTx.getTxnType() == ttFEE);
900
901 BEAST_EXPECT(feeTx.getAccountID(sfAccount) == AccountID());
902 BEAST_EXPECT(feeTx.getFieldU32(sfLedgerSequence) == ledger->seq() + 1);
903
904 BEAST_EXPECT(feeTx.isFieldPresent(sfBaseFeeDrops));
905 BEAST_EXPECT(feeTx.isFieldPresent(sfReserveBaseDrops));
906 BEAST_EXPECT(feeTx.isFieldPresent(sfReserveIncrementDrops));
907
908 // The legacy fields should NOT be present
909 BEAST_EXPECT(!feeTx.isFieldPresent(sfBaseFee));
910 BEAST_EXPECT(!feeTx.isFieldPresent(sfReserveBase));
911 BEAST_EXPECT(!feeTx.isFieldPresent(sfReserveIncrement));
912 BEAST_EXPECT(!feeTx.isFieldPresent(sfReferenceFeeUnits));
913
914 // Check the values
915 BEAST_EXPECT(feeTx.getFieldAmount(sfBaseFeeDrops) == XRPAmount{setup.referenceFee});
916 BEAST_EXPECT(feeTx.getFieldAmount(sfReserveBaseDrops) == XRPAmount{setup.accountReserve});
917 BEAST_EXPECT(
918 feeTx.getFieldAmount(sfReserveIncrementDrops) == XRPAmount{setup.ownerReserve});
919 }
920
921 void
923 {
924 testcase("genesis FeeSettings carries the configured gas settings");
925
926 using namespace jtx;
927
928 Env env(*this, testableAmendments());
929 auto const& cfg = env.app().config().fees;
930 BEAST_EXPECT(cfg.gasLimit != 0 && cfg.bytecodeSizeLimit != 0 && cfg.gasPrice != 0);
931
932 auto const genesisWith = [&](std::vector<UInt256> const& amendments) {
936 amendments.begin(), amendments.end()}},
937 cfg.toFees(),
938 amendments,
939 env.app().getNodeFamily());
940 };
941
942 {
943 // With the amendment, the operator's configuration becomes the
944 // network's starting point.
945 auto const ledger = genesisWith({featureSmartEscrow});
946 auto const sle = ledger->read(keylet::feeSettings());
947 if (BEAST_EXPECT(sle))
948 {
949 BEAST_EXPECT(sle->getFieldU32(sfGasLimit) == cfg.gasLimit);
950 BEAST_EXPECT(sle->getFieldU32(sfBytecodeSizeLimit) == cfg.bytecodeSizeLimit);
951 BEAST_EXPECT(sle->getFieldU32(sfGasPrice) == cfg.gasPrice);
952 }
953 BEAST_EXPECT(ledger->fees().gasLimit == cfg.gasLimit);
954 BEAST_EXPECT(ledger->fees().bytecodeSizeLimit == cfg.bytecodeSizeLimit);
955 BEAST_EXPECT(ledger->fees().gasPrice == cfg.gasPrice);
956 }
957
958 {
959 // Without it, the entry carries nothing.
960 auto const ledger = genesisWith({});
961 auto const sle = ledger->read(keylet::feeSettings());
962 if (BEAST_EXPECT(sle))
963 {
964 BEAST_EXPECT(!sle->isFieldPresent(sfGasLimit));
965 BEAST_EXPECT(!sle->isFieldPresent(sfBytecodeSizeLimit));
966 BEAST_EXPECT(!sle->isFieldPresent(sfGasPrice));
967 }
968 }
969 }
970
971 void
973 {
974 testcase("doVoting votes for nothing before Smart Escrow");
975
976 using namespace jtx;
977
978 // Before the amendment, gas settings that differ from the config
979 // targets must not count as a change, or every node emits a SetFee on
980 // every flag ledger for as long as the amendment is off.
981 Env env(*this, testableAmendments() - featureSmartEscrow);
982
983 FeeSetup setup;
984 setup.referenceFee = UNIT_TEST_REFERENCE_FEE;
985 setup.accountReserve = 200'000'000;
986 setup.ownerReserve = 50'000'000;
987 BEAST_EXPECT(setup.gasLimit != 0);
988 BEAST_EXPECT(setup.bytecodeSizeLimit != 0);
989 BEAST_EXPECT(setup.gasPrice != 0);
990
991 // Zero gas settings, unlike the config targets, so the three votes
992 // would report a change if they were counted.
993 Fees const ledgerFees{
994 setup.referenceFee, setup.accountReserve, setup.ownerReserve, 0, 0, 0};
995
996 auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote"));
997 auto ledger = std::make_shared<Ledger>(
999 Rules{env.app().config().features},
1000 ledgerFees,
1002 env.app().getNodeFamily());
1003
1004 for (int i = 0; i < 256 - 1; ++i)
1005 {
1006 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
1007 }
1008 BEAST_EXPECT(ledger->isFlagLedger());
1009 BEAST_EXPECT(ledger->fees().gasLimit == 0);
1010
1012 for (int i = 0; i < 5; i++)
1013 {
1014 auto const sec = randomSecretKey();
1015 auto const pub = derivePublicKey(KeyType::Secp256k1, sec);
1016
1017 auto const val = std::make_shared<STValidation>(
1018 env.app().getTimeKeeper().now(), pub, sec, calcNodeID(pub), [&](STValidation& v) {
1019 v.setFieldU32(sfLedgerSequence, ledger->seq());
1020 // Everyone is content with the fees as they stand.
1021 v.setFieldAmount(sfBaseFeeDrops, XRPAmount{setup.referenceFee});
1022 v.setFieldAmount(sfReserveBaseDrops, XRPAmount{setup.accountReserve});
1023 v.setFieldAmount(sfReserveIncrementDrops, XRPAmount{setup.ownerReserve});
1024 });
1025 if ((i % 2) != 0)
1026 val->setTrusted();
1027 validations.push_back(val);
1028 }
1029
1030 auto const txSet =
1032 feeVote->doVoting(ledger, validations, txSet);
1033
1034 BEAST_EXPECT(getTxs(txSet).empty());
1035 }
1036
1037 void
1039 {
1040 testcase("doVoting with Smart Escrow");
1041
1042 using namespace jtx;
1043
1044 Env env(*this, testableAmendments());
1045
1046 // establish what the current fees are
1047 BEAST_EXPECT(env.current()->fees().base == XRPAmount{UNIT_TEST_REFERENCE_FEE});
1048 BEAST_EXPECT(env.current()->fees().reserve == XRPAmount{200'000'000});
1049 BEAST_EXPECT(env.current()->fees().increment == XRPAmount{50'000'000});
1050 BEAST_EXPECT(env.current()->fees().gasLimit == kDefaultGasLimit);
1051 BEAST_EXPECT(env.current()->fees().bytecodeSizeLimit == kDefaultBytecodeSizeLimit);
1052 BEAST_EXPECT(env.current()->fees().gasPrice == kDefaultGasPrice);
1053
1054 struct SeVoteOpts
1055 {
1056 // If set, each validation uses the returned price; nullopt omits
1057 // sfGasPrice. If unset, every validation uses setup.gasPrice.
1059 int nValidations = 5;
1060 bool trustAll = false;
1061 };
1062
1063 auto const createFeeTxFromVoting =
1064 [&](FeeSetup const& setup,
1065 SeVoteOpts const& opts = {}) -> std::pair<STTx, std::shared_ptr<Ledger>> {
1066 auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote"));
1067 auto ledger = std::make_shared<Ledger>(
1069 Rules{env.app().config().features},
1070 env.app().config().fees.toFees(),
1072 env.app().getNodeFamily());
1073
1074 // doVoting requires a flag ledger (every 256th ledger)
1075 // We need to create a ledger at sequence 256 to make it a flag
1076 // ledger
1077 for (int i = 0; i < 256 - 1; ++i)
1078 {
1079 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
1080 }
1081 BEAST_EXPECT(ledger->isFlagLedger());
1082
1083 // Create some mock validations with fee votes
1085
1086 for (int i = 0; i < opts.nValidations; i++)
1087 {
1088 auto const sec = randomSecretKey();
1089 auto const pub = derivePublicKey(KeyType::Secp256k1, sec);
1090
1091 auto const val = std::make_shared<STValidation>(
1092 env.app().getTimeKeeper().now(),
1093 pub,
1094 sec,
1095 calcNodeID(pub),
1096 [&](STValidation& v) {
1097 v.setFieldU32(sfLedgerSequence, ledger->seq());
1098 // Vote for different fees than current
1099 v.setFieldAmount(sfBaseFeeDrops, XRPAmount{setup.referenceFee});
1100 v.setFieldAmount(sfReserveBaseDrops, XRPAmount{setup.accountReserve});
1101 v.setFieldAmount(sfReserveIncrementDrops, XRPAmount{setup.ownerReserve});
1102 v.setFieldU32(sfGasLimit, setup.gasLimit);
1103 v.setFieldU32(sfBytecodeSizeLimit, setup.bytecodeSizeLimit);
1104 if (opts.gasPrice)
1105 {
1106 if (auto const price = opts.gasPrice(i))
1107 v.setFieldU32(sfGasPrice, *price);
1108 }
1109 else
1110 {
1111 v.setFieldU32(sfGasPrice, setup.gasPrice);
1112 }
1113 });
1114 if (opts.trustAll || (i % 2))
1115 val->setTrusted();
1116 validations.push_back(val);
1117 }
1118
1119 auto const txSet =
1121
1122 // This should not throw since we have a flag ledger
1123 feeVote->doVoting(ledger, validations, txSet);
1124
1125 auto const txs = getTxs(txSet);
1126 BEAST_EXPECT(txs.size() == 1);
1127 return {txs[0], ledger};
1128 };
1129
1130 auto const checkFeeTx = [&](FeeSetup const& setup,
1131 STTx const& feeTx,
1132 std::shared_ptr<Ledger> const& ledger,
1133 std::source_location const loc =
1135 auto const line = " (" + std::to_string(loc.line()) + ")";
1136 BEAST_EXPECTS(feeTx.getTxnType() == ttFEE, line);
1137
1138 BEAST_EXPECTS(feeTx.getAccountID(sfAccount) == AccountID(), line);
1139 BEAST_EXPECTS(feeTx.getFieldU32(sfLedgerSequence) == ledger->seq() + 1, line);
1140
1141 BEAST_EXPECTS(feeTx.isFieldPresent(sfBaseFeeDrops), line);
1142 BEAST_EXPECTS(feeTx.isFieldPresent(sfReserveBaseDrops), line);
1143 BEAST_EXPECTS(feeTx.isFieldPresent(sfReserveIncrementDrops), line);
1144
1145 // The legacy fields should NOT be present
1146 BEAST_EXPECTS(!feeTx.isFieldPresent(sfBaseFee), line);
1147 BEAST_EXPECTS(!feeTx.isFieldPresent(sfReserveBase), line);
1148 BEAST_EXPECTS(!feeTx.isFieldPresent(sfReserveIncrement), line);
1149 BEAST_EXPECTS(!feeTx.isFieldPresent(sfReferenceFeeUnits), line);
1150
1151 // Check the values
1152 BEAST_EXPECTS(
1153 feeTx.getFieldAmount(sfBaseFeeDrops) == XRPAmount{setup.referenceFee}, line);
1154 BEAST_EXPECTS(
1155 feeTx.getFieldAmount(sfReserveBaseDrops) == XRPAmount{setup.accountReserve}, line);
1156 BEAST_EXPECTS(
1157 feeTx.getFieldAmount(sfReserveIncrementDrops) == XRPAmount{setup.ownerReserve},
1158 line);
1159 BEAST_EXPECTS(feeTx.getFieldU32(sfGasLimit) == setup.gasLimit, line);
1160 BEAST_EXPECTS(feeTx.getFieldU32(sfBytecodeSizeLimit) == setup.bytecodeSizeLimit, line);
1161 BEAST_EXPECTS(feeTx.getFieldU32(sfGasPrice) == setup.gasPrice, line);
1162 };
1163
1164 {
1165 FeeSetup setup;
1166 setup.referenceFee = 42;
1167 setup.accountReserve = 1234567;
1168 setup.ownerReserve = 7654321;
1169 setup.gasLimit = 100;
1170 setup.bytecodeSizeLimit = 200;
1171 setup.gasPrice = 300;
1172 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1173
1174 checkFeeTx(setup, feeTx, ledger);
1175 }
1176
1177 {
1178 FeeSetup setup;
1179 setup.referenceFee = 42;
1180 setup.accountReserve = 1234567;
1181 setup.ownerReserve = 7654321;
1182 setup.gasLimit = 0;
1183 setup.bytecodeSizeLimit = 0;
1184 setup.gasPrice = 300;
1185 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1186
1187 checkFeeTx(setup, feeTx, ledger);
1188 }
1189
1190 {
1191 FeeSetup setup;
1192 setup.referenceFee = 42;
1193 setup.accountReserve = 1234567;
1194 setup.ownerReserve = 7654321;
1195 setup.gasLimit = kMaxGasLimit + 1;
1197 setup.gasPrice = 300;
1198 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1199
1200 setup.gasLimit = ledger->fees().gasLimit;
1201 setup.bytecodeSizeLimit = ledger->fees().bytecodeSizeLimit;
1202 checkFeeTx(setup, feeTx, ledger);
1203 }
1204
1205 // Local and peer votes of 0 are ignored; the fee tx keeps the ledger
1206 // gas price. Other fee fields still change, so a ttFEE is produced.
1207 {
1208 FeeSetup setup;
1209 setup.referenceFee = 42;
1210 setup.accountReserve = 1234567;
1211 setup.ownerReserve = 7654321;
1212 setup.gasLimit = 100;
1213 setup.bytecodeSizeLimit = 200;
1214 setup.gasPrice = 0;
1215 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1216
1217 setup.gasPrice = ledger->fees().gasPrice;
1218 checkFeeTx(setup, feeTx, ledger);
1219 }
1220
1221 // Absent sfGasPrice is an abstention (noVote), not a vote for 0.
1222 {
1223 FeeSetup setup;
1224 setup.referenceFee = 42;
1225 setup.accountReserve = 1234567;
1226 setup.ownerReserve = 7654321;
1227 setup.gasLimit = 100;
1228 setup.bytecodeSizeLimit = 200;
1229 setup.gasPrice = 300;
1230 auto const [feeTx, ledger] = createFeeTxFromVoting(
1231 setup,
1232 {.gasPrice = [](int) -> std::optional<std::uint32_t> { return std::nullopt; }});
1233
1234 setup.gasPrice = ledger->fees().gasPrice;
1235 checkFeeTx(setup, feeTx, ledger);
1236 }
1237
1238 // Invalid (0) votes are noVote (weight on current), not dropped.
1239 // Four zeros and one 300: current outweighs 300. If zeros were
1240 // ignored, the local 300 target would still win.
1241 {
1242 FeeSetup setup;
1243 setup.referenceFee = 42;
1244 setup.accountReserve = 1234567;
1245 setup.ownerReserve = 7654321;
1246 setup.gasLimit = 100;
1247 setup.bytecodeSizeLimit = 200;
1248 setup.gasPrice = 300;
1249 auto const [feeTx, ledger] = createFeeTxFromVoting(
1250 setup,
1251 {
1252 .gasPrice = [](int i) -> std::optional<std::uint32_t> {
1253 return i == 0 ? 300 : 0;
1254 },
1255 .trustAll = true,
1256 });
1257
1258 setup.gasPrice = ledger->fees().gasPrice;
1259 checkFeeTx(setup, feeTx, ledger);
1260 }
1261
1262 // doVote accepts the inclusive floor (field >= kMinGasPrice).
1263 {
1264 FeeSetup setup;
1265 setup.referenceFee = 42;
1266 setup.accountReserve = 1234567;
1267 setup.ownerReserve = 7654321;
1268 setup.gasLimit = 100;
1269 setup.bytecodeSizeLimit = 200;
1270 setup.gasPrice = kMinGasPrice;
1271 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1272
1273 checkFeeTx(setup, feeTx, ledger);
1274 }
1275
1276 // There is no protocol max for gas price; UINT32_MAX is a legal vote.
1277 {
1278 FeeSetup setup;
1279 setup.referenceFee = 42;
1280 setup.accountReserve = 1234567;
1281 setup.ownerReserve = 7654321;
1282 setup.gasLimit = 100;
1283 setup.bytecodeSizeLimit = 200;
1285 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1286
1287 checkFeeTx(setup, feeTx, ledger);
1288 }
1289 }
1290
1291 // Activation cannot be driven through consensus here, so the ledger is
1292 // built by hand and wrapped in an OpenView, which reports closed --
1293 // Change::preclaim rejects pseudo-transactions against an open view.
1294 void
1296 {
1297 testcase("Seeding on amendment activation");
1298
1299 using namespace jtx;
1300
1301 // env is only a factory for Rules, Fees, a family and a journal.
1302 Env env(*this, testableAmendments() - featureSmartEscrow);
1303
1304 // Activation creates FeeSettings if the ledger has none.
1305 for (bool const hasFeeSettings : {true, false})
1306 {
1307 auto ledger = std::make_shared<Ledger>(
1309 Rules{env.app().config().features},
1310 env.app().config().fees.toFees(),
1312 env.app().getNodeFamily());
1313 // One successor, so the amendment is not applied to genesis itself.
1314 ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
1315
1316 if (!hasFeeSettings)
1317 {
1318 ledger->rawErase(keylet::feeSettings().key);
1319 }
1320 else if (auto const before = ledger->read(keylet::feeSettings()); BEAST_EXPECT(before))
1321 {
1322 BEAST_EXPECT(!before->isFieldPresent(sfGasLimit));
1323 BEAST_EXPECT(!before->isFieldPresent(sfBytecodeSizeLimit));
1324 BEAST_EXPECT(!before->isFieldPresent(sfGasPrice));
1325 }
1326
1327 STTx const amendTx(ttAMENDMENT, [&](auto& obj) {
1328 obj.setAccountID(sfAccount, AccountID());
1329 obj.setFieldH256(sfAmendment, featureSmartEscrow);
1330 obj.setFieldU32(sfLedgerSequence, ledger->seq());
1331 });
1332
1333 {
1334 OpenView accum(ledger.get());
1335 BEAST_EXPECT(!accum.open());
1336
1337 auto const result =
1338 apply(env.app(), accum, amendTx, ApplyFlags::TapNone, env.journal);
1339 BEAST_EXPECTS(result.applied && isTesSuccess(result.ter), transToken(result.ter));
1340 accum.apply(*ledger);
1341 }
1342
1343 auto const after = ledger->read(keylet::feeSettings());
1344 if (!BEAST_EXPECT(after))
1345 continue;
1346
1347 if (BEAST_EXPECT(after->isFieldPresent(sfGasLimit)))
1348 {
1349 BEAST_EXPECTS(
1350 after->getFieldU32(sfGasLimit) == kDefaultGasLimit,
1351 std::to_string(after->getFieldU32(sfGasLimit)));
1352 }
1353 if (BEAST_EXPECT(after->isFieldPresent(sfBytecodeSizeLimit)))
1354 {
1355 BEAST_EXPECTS(
1356 after->getFieldU32(sfBytecodeSizeLimit) == kDefaultBytecodeSizeLimit,
1357 std::to_string(after->getFieldU32(sfBytecodeSizeLimit)));
1358 }
1359 if (BEAST_EXPECT(after->isFieldPresent(sfGasPrice)))
1360 {
1361 BEAST_EXPECTS(
1362 after->getFieldU32(sfGasPrice) == kDefaultGasPrice,
1363 std::to_string(after->getFieldU32(sfGasPrice)));
1364 }
1365
1366 // Also pins that the amendment is seen before the fee fields are read.
1367 BEAST_EXPECT(ledger->setImmutable());
1368 BEAST_EXPECT(ledger->rules().enabled(featureSmartEscrow));
1369 BEAST_EXPECT(ledger->fees().gasLimit == kDefaultGasLimit);
1370 BEAST_EXPECT(ledger->fees().bytecodeSizeLimit == kDefaultBytecodeSizeLimit);
1371 BEAST_EXPECT(ledger->fees().gasPrice == kDefaultGasPrice);
1372 }
1373 }
1374
1375 void
1393};
1394
1396
1397} // namespace xrpl::test
A testsuite class.
Definition suite.h:52
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
virtual Config & config()=0
std::unordered_set< UInt256, beast::Uhash<> > features
Manager to process fee votes.
Definition FeeVote.h:19
Writable ledger view that accumulates state and tx changes.
Definition OpenView.h:59
bool open() const override
Returns true if this reflects an open ledger.
Definition OpenView.h:187
void apply(TxsRawView &to) const
Apply changes.
Definition OpenView.cpp:129
Rules controlling protocol behavior.
Definition Rules.h:40
bool enabled(UInt256 const &feature) const
Returns true if a feature is enabled.
Definition Rules.cpp:182
std::uint32_t getFieldU32(SField const &field) const
Definition STObject.cpp:601
void setFieldU32(SField const &field, std::uint32_t)
Definition STObject.cpp:743
void setFieldAmount(SField const &field, STAmount const &)
Definition STObject.cpp:803
std::uint64_t getFieldU64(SField const &field) const
Definition STObject.cpp:607
Holds a collection of configuration values.
Definition BasicConfig.h:28
void append(std::vector< std::string > const &lines)
Append a set of lines to this section.
Slice slice() const noexcept
Definition Serializer.h:141
virtual beast::Journal getJournal(std::string const &name)=0
virtual Family & getNodeFamily()=0
virtual TimeKeeper & getTimeKeeper()=0
time_point now() const override
Returns the current time, using the server's clock.
Definition TimeKeeper.h:48
time_point closeTime() const
Returns the predicted close time, in network time.
Definition TimeKeeper.h:61
void run() override
Runs the suite.
A transaction testing environment.
Definition Env.h:161
Application & app()
Definition Env.h:300
beast::Journal const journal
Definition Env.h:204
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition Env.h:377
T current(T... args)
T emplace_back(T... args)
T make_shared(T... args)
T max(T... args)
Keylet const & feeSettings() noexcept
The (fixed) index of the object containing the ledger fees.
Definition Indexes.cpp:267
FeatureBitset testableAmendments()
Definition Env.h:92
bool verifyFeeObject(std::shared_ptr< Ledger const > const &ledger, Rules const &rules, FeeSettingsFields const &expected)
STTx createFeeTxWithLegacyFields(std::uint32_t seq)
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
STTx createFeeTxMissingRequiredFields(std::uint32_t seq)
TER applyFeeAndTestResult(jtx::Env &env, OpenView &view, STTx const &tx)
STTx createFeeTx(Rules const &rules, std::uint32_t seq, FeeSettingsFields const &fields, bool forceAllFields=false)
constexpr XRPAmount
Convert XRP to drops (integral types).
Definition TxTest.h:53
std::vector< STTx > getTxs(std::shared_ptr< SHAMap > const &txSet)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
PublicKey derivePublicKey(KeyType type, SecretKey const &sk)
Derive the public key from a secret key.
constexpr std::uint32_t kDefaultGasLimit
constexpr std::uint32_t kMinGasPrice
ApplyResult apply(ServiceRegistry &registry, OpenView &view, STTx const &tx, ApplyFlags flags, beast::Journal journal)
Apply a transaction to an OpenView.
Definition apply.cpp:181
CreateGenesisT const kCreateGenesis
std::unique_ptr< FeeVote > makeFeeVote(FeeSetup const &setup, beast::Journal journal)
Create an instance of the FeeVote logic.
FeeSetup setupFeeVote(Section const &section)
std::string transToken(TER code)
Definition TER.cpp:259
NodeID calcNodeID(PublicKey const &)
Calculate the 160-bit node ID from a node public key.
SecretKey randomSecretKey()
Create a secret key using secure random numbers.
bool after(NetClock::time_point now, std::uint32_t mark)
Has the specified time passed?
Definition View.cpp:668
constexpr std::uint32_t kDefaultGasPrice
constexpr std::uint32_t kDefaultBytecodeSizeLimit
@ TapNone
Definition ApplyView.h:28
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
Definition AccountID.h:34
@ temMALFORMED
Definition TER.h:75
bool isTesSuccess(TER x) noexcept
Definition TER.h:686
TERSubset< CanCvtToTER > TER
Definition TER.h:657
constexpr std::uint32_t kMaxGasLimit
Hard protocol bounds on the Feature Extension fee settings.
constexpr std::uint32_t kMaxBytecodeSizeLimit
T push_back(T... args)
Fee schedule for startup / standalone, and to vote for.
XRPAmount accountReserve
The account reserve requirement in drops.
XRPAmount ownerReserve
The per-owned item reserve requirement in drops.
XRPAmount referenceFee
The cost of a reference transaction in drops.
std::uint32_t gasPrice
The price of 1 WASM gas, in micro-drops.
std::uint32_t bytecodeSizeLimit
The bytecode size limit for Feature Extensions.
std::uint32_t gasLimit
The gas limit for Feature Extensions.
Reflects the fee settings for a particular ledger.
std::optional< std::uint32_t > gasPrice
std::optional< XRPAmount > reserveIncrementDrops
std::optional< XRPAmount > baseFeeDrops
std::optional< XRPAmount > reserveBaseDrops
std::optional< std::uint32_t > gasLimit
std::optional< std::uint32_t > bytecodeSizeLimit
T to_string(T... args)
T value_or(T... args)