2#include <test/jtx/Env.h>
4#include <xrpld/app/misc/FeeVote.h>
5#include <xrpld/core/Config.h>
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>
37#include <source_location>
60 bool forceAllFields =
false)
62 auto const fill = [&](
auto& obj) {
64 obj.setFieldU32(sfLedgerSequence, seq);
72 sfReserveIncrementDrops,
74 if (rules.
enabled(featureSmartEscrow) || forceAllFields)
82 return STTx(ttFEE, fill);
89 return STTx(ttFEE, [&](
auto& obj) {
91 obj.setFieldU32(sfLedgerSequence, seq);
101 return STTx(ttFEE, [&](
auto& obj) {
102 obj.setAccountID(sfAccount,
AccountID());
103 obj.setFieldU32(sfLedgerSequence, seq);
105 obj.setFieldAmount(sfBaseFeeDrops,
XRPAmount{10});
106 obj.setFieldAmount(sfReserveBaseDrops,
XRPAmount{200000});
107 obj.setFieldAmount(sfReserveIncrementDrops,
XRPAmount{50000});
109 obj.setFieldU64(sfBaseFee, 10);
110 obj.setFieldU32(sfReserveBase, 200000);
111 obj.setFieldU32(sfReserveIncrement, 50000);
112 obj.setFieldU32(sfReferenceFeeUnits, 10);
133 auto const checkEquality = [&](
auto const& field,
auto const& expected) {
134 if (!feeObject->isFieldPresent(field))
136 return feeObject->at(field) == expected;
139 if (feeObject->isFieldPresent(sfBaseFee) || feeObject->isFieldPresent(sfReserveBase) ||
140 feeObject->isFieldPresent(sfReserveIncrement) ||
141 feeObject->isFieldPresent(sfReferenceFeeUnits))
151 if (rules.
enabled(featureSmartEscrow))
162 if (feeObject->isFieldPresent(sfGasLimit) ||
163 feeObject->isFieldPresent(sfBytecodeSizeLimit) || feeObject->isFieldPresent(sfGasPrice))
174 for (
auto i = txSet->begin(); i != txSet->end(); ++i)
176 auto const data = i->slice();
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);
199 BEAST_EXPECT(setup.gasPrice == defaultSetup.
gasPrice);
204 "reference_fee = 50",
205 "account_reserve = 1234567",
206 "owner_reserve = 1234",
208 "bytecode_size_limit = 200",
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);
222 "reference_fee = blah",
223 "account_reserve = yada",
224 "owner_reserve = foo",
226 "bytecode_size_limit = baz",
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);
236 BEAST_EXPECT(setup.gasPrice == defaultSetup.
gasPrice);
241 "reference_fee = -50",
242 "account_reserve = -1234567",
243 "owner_reserve = -1234",
245 "bytecode_size_limit = -200",
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);
256 BEAST_EXPECT(setup.gasPrice == defaultSetup.
gasPrice);
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,
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);
277 BEAST_EXPECT(setup.gasPrice == defaultSetup.
gasPrice);
286 BEAST_EXPECT(setup.gasLimit == defaultSetup.
gasLimit);
302 config.
append(
"gas_price = 0");
304 BEAST_EXPECT(setup.gasPrice == defaultSetup.
gasPrice);
318 testcase(
"Basic SetFee transaction");
326 env.
app().config().fees.toFees(),
336 .reserveIncrementDrops =
XRPAmount{50000},
339 auto const feeTx =
createFeeTx(ledger->rules(), ledger->seq(), fields);
343 accum.
apply(*ledger);
355 env.
app().config().fees.toFees(),
365 .reserveIncrementDrops =
XRPAmount{50000},
367 .bytecodeSizeLimit = 200,
371 auto const feeTx =
createFeeTx(ledger->rules(), ledger->seq(), fields);
375 accum.
apply(*ledger);
387 env.
app().config().fees.toFees(),
394 auto const feeTx =
createFeeTx(ledger->rules(), ledger->seq(), fields);
402 .reserveIncrementDrops =
XRPAmount{50000},
410 .reserveIncrementDrops =
XRPAmount{50000},
420 .reserveIncrementDrops =
XRPAmount{50000},
433 env.
app().config().fees.toFees(),
442 .reserveIncrementDrops =
XRPAmount{50000},
444 .bytecodeSizeLimit = 200,
447 auto const feeTx =
createFeeTx(ledger->rules(), ledger->seq(), fields);
451 accum.
apply(*ledger);
463 env.
app().config().fees.toFees(),
473 .reserveIncrementDrops =
XRPAmount{50000},
475 .bytecodeSizeLimit = 200,
479 auto const feeTx =
createFeeTx(ledger->rules(), ledger->seq(), fields,
true);
489 testcase(
"Fee Transaction Validation");
496 env.
app().config().fees.toFees(),
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);
530 env.
app().config().fees.toFees(),
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});
562 testcase(
"Pseudo Transaction Properties");
568 env.
app().config().fees.toFees(),
579 .baseFeeDrops = XRPAmount{10},
581 .reserveIncrementDrops =
XRPAmount{50000},
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));
609 env.
app().config().fees.toFees(),
618 .reserveIncrementDrops =
XRPAmount{50000},
620 auto const feeTx1 =
createFeeTx(ledger->rules(), ledger->seq(), fields1);
625 accum.
apply(*ledger);
636 .reserveIncrementDrops =
XRPAmount{75000},
638 auto const feeTx2 =
createFeeTx(ledger->rules(), ledger->seq(), fields2);
643 accum.
apply(*ledger);
659 env.
app().config().fees.toFees(),
670 .baseFeeDrops = XRPAmount{10},
672 .reserveIncrementDrops =
XRPAmount{50000},
692 env.
app().config().fees.toFees(),
701 .reserveIncrementDrops =
XRPAmount{50000},
703 auto const feeTx1 =
createFeeTx(ledger->rules(), ledger->seq(), fields1);
708 accum.
apply(*ledger);
720 auto const feeTx2 =
createFeeTx(ledger->rules(), ledger->seq(), fields2);
725 accum.
apply(*ledger);
735 testcase(
"Single Invalid Transaction");
741 env.
app().config().fees.toFees(),
749 auto const invalidTx =
STTx(ttFEE, [&](
auto& obj) {
750 obj.setAccountID(sfAccount,
752 obj.setFieldU32(sfLedgerSequence, ledger->seq());
753 obj.setFieldAmount(sfBaseFeeDrops,
XRPAmount{10});
754 obj.setFieldAmount(sfReserveBaseDrops,
XRPAmount{200000});
755 obj.setFieldAmount(sfReserveIncrementDrops,
XRPAmount{50000});
782 env.
app().config().fees.toFees(),
796 auto const& currentFees = ledger->fees();
798 feeVote->doValidation(currentFees, ledger->rules(), *val);
800 BEAST_EXPECT(val->isFieldPresent(sfBaseFeeDrops));
815 env.
app().config().fees.toFees(),
827 feeVote->doValidation(ledger->fees(), ledger->rules(), *val);
829 BEAST_EXPECT(!val->isFieldPresent(sfGasPrice));
848 BEAST_EXPECT(env.
current()->fees().base ==
XRPAmount{UNIT_TEST_REFERENCE_FEE});
856 env.
app().config().fees.toFees(),
862 for (
int i = 0; i < 256 - 1; ++i)
866 BEAST_EXPECT(ledger->isFlagLedger());
871 for (
int i = 0; i < 5; i++)
893 feeVote->doVoting(ledger, validations, txSet);
895 auto const txs =
getTxs(txSet);
896 BEAST_EXPECT(txs.size() == 1);
897 auto const& feeTx = txs[0];
899 BEAST_EXPECT(feeTx.getTxnType() == ttFEE);
901 BEAST_EXPECT(feeTx.getAccountID(sfAccount) ==
AccountID());
902 BEAST_EXPECT(feeTx.getFieldU32(sfLedgerSequence) == ledger->seq() + 1);
904 BEAST_EXPECT(feeTx.isFieldPresent(sfBaseFeeDrops));
905 BEAST_EXPECT(feeTx.isFieldPresent(sfReserveBaseDrops));
906 BEAST_EXPECT(feeTx.isFieldPresent(sfReserveIncrementDrops));
909 BEAST_EXPECT(!feeTx.isFieldPresent(sfBaseFee));
910 BEAST_EXPECT(!feeTx.isFieldPresent(sfReserveBase));
911 BEAST_EXPECT(!feeTx.isFieldPresent(sfReserveIncrement));
912 BEAST_EXPECT(!feeTx.isFieldPresent(sfReferenceFeeUnits));
915 BEAST_EXPECT(feeTx.getFieldAmount(sfBaseFeeDrops) ==
XRPAmount{setup.referenceFee});
916 BEAST_EXPECT(feeTx.getFieldAmount(sfReserveBaseDrops) ==
XRPAmount{setup.accountReserve});
918 feeTx.getFieldAmount(sfReserveIncrementDrops) ==
XRPAmount{setup.ownerReserve});
924 testcase(
"genesis FeeSettings carries the configured gas settings");
930 BEAST_EXPECT(cfg.gasLimit != 0 && cfg.bytecodeSizeLimit != 0 && cfg.gasPrice != 0);
936 amendments.begin(), amendments.end()}},
945 auto const ledger = genesisWith({featureSmartEscrow});
947 if (BEAST_EXPECT(sle))
949 BEAST_EXPECT(sle->getFieldU32(sfGasLimit) == cfg.gasLimit);
950 BEAST_EXPECT(sle->getFieldU32(sfBytecodeSizeLimit) == cfg.bytecodeSizeLimit);
951 BEAST_EXPECT(sle->getFieldU32(sfGasPrice) == cfg.gasPrice);
953 BEAST_EXPECT(ledger->fees().gasLimit == cfg.gasLimit);
954 BEAST_EXPECT(ledger->fees().bytecodeSizeLimit == cfg.bytecodeSizeLimit);
955 BEAST_EXPECT(ledger->fees().gasPrice == cfg.gasPrice);
960 auto const ledger = genesisWith({});
962 if (BEAST_EXPECT(sle))
964 BEAST_EXPECT(!sle->isFieldPresent(sfGasLimit));
965 BEAST_EXPECT(!sle->isFieldPresent(sfBytecodeSizeLimit));
966 BEAST_EXPECT(!sle->isFieldPresent(sfGasPrice));
974 testcase(
"doVoting votes for nothing before Smart Escrow");
993 Fees const ledgerFees{
1002 env.
app().getNodeFamily());
1004 for (
int i = 0; i < 256 - 1; ++i)
1008 BEAST_EXPECT(ledger->isFlagLedger());
1009 BEAST_EXPECT(ledger->fees().gasLimit == 0);
1012 for (
int i = 0; i < 5; i++)
1032 feeVote->doVoting(ledger, validations, txSet);
1034 BEAST_EXPECT(
getTxs(txSet).empty());
1040 testcase(
"doVoting with Smart Escrow");
1042 using namespace jtx;
1047 BEAST_EXPECT(env.
current()->fees().base ==
XRPAmount{UNIT_TEST_REFERENCE_FEE});
1059 int nValidations = 5;
1060 bool trustAll =
false;
1063 auto const createFeeTxFromVoting =
1070 env.
app().config().fees.toFees(),
1077 for (
int i = 0; i < 256 - 1; ++i)
1081 BEAST_EXPECT(ledger->isFlagLedger());
1086 for (
int i = 0; i < opts.nValidations; i++)
1106 if (
auto const price = opts.gasPrice(i))
1114 if (opts.trustAll || (i % 2))
1123 feeVote->doVoting(ledger, validations, txSet);
1125 auto const txs =
getTxs(txSet);
1126 BEAST_EXPECT(txs.size() == 1);
1127 return {txs[0], ledger};
1130 auto const checkFeeTx = [&](
FeeSetup const& setup,
1136 BEAST_EXPECTS(feeTx.getTxnType() == ttFEE, line);
1138 BEAST_EXPECTS(feeTx.getAccountID(sfAccount) ==
AccountID(), line);
1139 BEAST_EXPECTS(feeTx.getFieldU32(sfLedgerSequence) == ledger->seq() + 1, line);
1141 BEAST_EXPECTS(feeTx.isFieldPresent(sfBaseFeeDrops), line);
1142 BEAST_EXPECTS(feeTx.isFieldPresent(sfReserveBaseDrops), line);
1143 BEAST_EXPECTS(feeTx.isFieldPresent(sfReserveIncrementDrops), line);
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);
1153 feeTx.getFieldAmount(sfBaseFeeDrops) ==
XRPAmount{setup.referenceFee}, line);
1155 feeTx.getFieldAmount(sfReserveBaseDrops) ==
XRPAmount{setup.accountReserve}, line);
1157 feeTx.getFieldAmount(sfReserveIncrementDrops) ==
XRPAmount{setup.ownerReserve},
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);
1172 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1174 checkFeeTx(setup, feeTx, ledger);
1185 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1187 checkFeeTx(setup, feeTx, ledger);
1198 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1200 setup.
gasLimit = ledger->fees().gasLimit;
1202 checkFeeTx(setup, feeTx, ledger);
1215 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1217 setup.
gasPrice = ledger->fees().gasPrice;
1218 checkFeeTx(setup, feeTx, ledger);
1230 auto const [feeTx, ledger] = createFeeTxFromVoting(
1234 setup.
gasPrice = ledger->fees().gasPrice;
1235 checkFeeTx(setup, feeTx, ledger);
1249 auto const [feeTx, ledger] = createFeeTxFromVoting(
1253 return i == 0 ? 300 : 0;
1258 setup.
gasPrice = ledger->fees().gasPrice;
1259 checkFeeTx(setup, feeTx, ledger);
1271 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1273 checkFeeTx(setup, feeTx, ledger);
1285 auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
1287 checkFeeTx(setup, feeTx, ledger);
1297 testcase(
"Seeding on amendment activation");
1299 using namespace jtx;
1305 for (
bool const hasFeeSettings : {
true,
false})
1310 env.
app().config().fees.toFees(),
1316 if (!hasFeeSettings)
1322 BEAST_EXPECT(!before->isFieldPresent(sfGasLimit));
1323 BEAST_EXPECT(!before->isFieldPresent(sfBytecodeSizeLimit));
1324 BEAST_EXPECT(!before->isFieldPresent(sfGasPrice));
1327 STTx const amendTx(ttAMENDMENT, [&](
auto& obj) {
1328 obj.setAccountID(sfAccount,
AccountID());
1329 obj.setFieldH256(sfAmendment, featureSmartEscrow);
1330 obj.setFieldU32(sfLedgerSequence, ledger->seq());
1335 BEAST_EXPECT(!accum.
open());
1340 accum.
apply(*ledger);
1344 if (!BEAST_EXPECT(
after))
1347 if (BEAST_EXPECT(
after->isFieldPresent(sfGasLimit)))
1353 if (BEAST_EXPECT(
after->isFieldPresent(sfBytecodeSizeLimit)))
1359 if (BEAST_EXPECT(
after->isFieldPresent(sfGasPrice)))
1367 BEAST_EXPECT(ledger->setImmutable());
1368 BEAST_EXPECT(ledger->rules().enabled(featureSmartEscrow));
TestcaseT testcase
Memberspace for declaring test cases.
virtual Config & config()=0
std::unordered_set< UInt256, beast::Uhash<> > features
Manager to process fee votes.
Writable ledger view that accumulates state and tx changes.
bool open() const override
Returns true if this reflects an open ledger.
void apply(TxsRawView &to) const
Apply changes.
Rules controlling protocol behavior.
bool enabled(UInt256 const &feature) const
Returns true if a feature is enabled.
std::uint32_t getFieldU32(SField const &field) const
void setFieldU32(SField const &field, std::uint32_t)
void setFieldAmount(SField const &field, STAmount const &)
std::uint64_t getFieldU64(SField const &field) const
Holds a collection of configuration values.
void append(std::vector< std::string > const &lines)
Append a set of lines to this section.
Slice slice() const noexcept
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.
time_point closeTime() const
Returns the predicted close time, in network time.
void testTransactionValidation()
void testGenesisFeeSettings()
void testDoVotingSmartEscrow()
void testPartialFieldUpdates()
void testPseudoTransactionProperties()
void testMultipleFeeUpdates()
void testSeedingOnActivation()
void testDoVotingNoChangePreSmartEscrow()
void run() override
Runs the suite.
void testWrongLedgerSequence()
void testSingleInvalidTransaction()
A transaction testing environment.
beast::Journal const journal
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
T emplace_back(T... args)
Keylet const & feeSettings() noexcept
The (fixed) index of the object containing the ledger fees.
FeatureBitset testableAmendments()
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).
std::vector< STTx > getTxs(std::shared_ptr< SHAMap > const &txSet)
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
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 ®istry, OpenView &view, STTx const &tx, ApplyFlags flags, beast::Journal journal)
Apply a transaction to an OpenView.
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 §ion)
std::string transToken(TER code)
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?
constexpr std::uint32_t kDefaultGasPrice
constexpr std::uint32_t kDefaultBytecodeSizeLimit
BaseUInt< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
bool isTesSuccess(TER x) noexcept
TERSubset< CanCvtToTER > TER
constexpr std::uint32_t kMaxGasLimit
Hard protocol bounds on the Feature Extension fee settings.
constexpr std::uint32_t kMaxBytecodeSizeLimit
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