xrpld
Toggle main menu visibility
Loading...
Searching...
No Matches
tests
libxrpl
ledger
ExtensionFees.cpp
1
#include <xrpl/basics/base_uint.h>
2
#include <xrpl/basics/chrono.h>
3
#include <xrpl/beast/hash/uhash.h>
4
#include <xrpl/beast/utility/Journal.h>
5
#include <xrpl/ledger/Ledger.h>
6
#include <xrpl/nodestore/NodeObject.h>
7
#include <xrpl/protocol/Feature.h>
8
#include <xrpl/protocol/Fees.h>
9
#include <xrpl/protocol/Indexes.h>
10
#include <xrpl/protocol/Rules.h>
11
#include <xrpl/protocol/SField.h>
12
#include <xrpl/protocol/STLedgerEntry.h>
13
#include <xrpl/protocol/XRPAmount.h>
14
15
#include <gtest/gtest.h>
16
#include <shamap/common.h>
17
18
#include <
cstdint
>
19
#include <
memory
>
20
#include <
unordered_set
>
21
#include <
vector
>
22
23
namespace
xrpl::test
{
24
25
namespace
{
26
27
// Unlike every protocol constant, so an assertion cannot pass by chance.
28
constexpr
std::uint32_t kLocalGasLimit{123'457};
29
constexpr
std::uint32_t kLocalBytecodeSizeLimit{23'457};
30
constexpr
std::uint32_t kLocalGasPrice{7'654'321};
31
32
// Stands in for FeeSetup::toFees(): local configuration.
33
Fees
34
localFees()
35
{
36
return
Fees{
37
XRPAmount
{10},
38
XRPAmount
{10'000'000},
39
XRPAmount
{2'000'000},
40
kLocalGasLimit,
41
kLocalBytecodeSizeLimit,
42
kLocalGasPrice};
43
}
44
45
}
// namespace
46
47
struct
ExtensionFees
: ::testing::Test
48
{
49
std::unordered_set<UInt256, beast::Uhash<>
>
presets
;
50
tests::TestNodeFamily
family
{
beast::Journal
{
beast::Journal::getNullSink
()}};
51
52
std::shared_ptr<Ledger>
53
makeGenesis
(
std::vector<UInt256>
const
& amendments)
54
{
55
presets
.insert(amendments.begin(), amendments.end());
56
return
std::make_shared<Ledger>
(
57
kCreateGenesis
,
Rules
{
presets
}, localFees(), amendments,
family
);
58
}
59
60
// Closed successor with FeeSettings rewritten by `edit`; setImmutable runs
61
// Ledger::setup, so fees() is what the resolution produced. Its state is
62
// flushed to the node store, so it can be reloaded.
63
template
<
typename
F>
64
std::shared_ptr<Ledger>
65
successorWithFeeSettings
(
Ledger
const
& parent, F&& edit)
66
{
67
auto
ledger =
std::make_shared<Ledger>
(parent,
NetClock::time_point
{});
68
auto
const
sle =
std::make_shared<SLE>
(*ledger->read(
keylet::feeSettings
()));
69
edit(*sle);
70
ledger->rawReplace(sle);
71
ledger->stateMap().flushDirty(
NodeObjectType::AccountNode
);
72
EXPECT_TRUE(ledger->setImmutable());
73
return
ledger;
74
}
75
76
// Whether `ledger` loads back from the node store. Loading is the one
77
// place the result of Ledger::setup is reported.
78
bool
79
reloads
(
Ledger
const
& ledger)
80
{
81
bool
loaded =
false
;
82
Ledger
const
reloaded(
83
ledger.
header
(),
84
loaded,
85
false
,
86
Rules
{presets},
87
localFees(),
88
family
,
89
beast::Journal
{
beast::Journal::getNullSink
()});
90
return
loaded;
91
}
92
};
93
94
// test how Ledger::setup decides the three extension fee fields
95
96
// Genesis is the one place local configuration legitimately reaches the ledger.
97
TEST_F
(
ExtensionFees
, genesis_writes_the_configured_values)
98
{
99
auto
const
ledger = makeGenesis({featureSmartEscrow});
100
101
EXPECT_EQ(ledger->fees().gasLimit, kLocalGasLimit);
102
EXPECT_EQ(ledger->fees().bytecodeSizeLimit, kLocalBytecodeSizeLimit);
103
EXPECT_EQ(ledger->fees().gasPrice, kLocalGasPrice);
104
}
105
106
// Absent must resolve to the protocol constant, never to the constructed Fees,
107
// which every caller builds from local configuration.
108
TEST_F
(
ExtensionFees
, absent_fields_resolve_to_the_protocol_constants)
109
{
110
auto
const
genesis = makeGenesis({featureSmartEscrow});
111
112
auto
const
ledger = successorWithFeeSettings(*genesis, [](
SLE
& sle) {
113
sle.
makeFieldAbsent
(sfGasLimit);
114
sle.
makeFieldAbsent
(sfBytecodeSizeLimit);
115
sle.
makeFieldAbsent
(sfGasPrice);
116
});
117
118
ASSERT_TRUE(ledger->rules().enabled(featureSmartEscrow));
119
120
EXPECT_EQ(ledger->fees().gasLimit,
kDefaultGasLimit
);
121
EXPECT_EQ(ledger->fees().bytecodeSizeLimit,
kDefaultBytecodeSizeLimit
);
122
EXPECT_EQ(ledger->fees().gasPrice,
kDefaultGasPrice
);
123
124
EXPECT_NE(ledger->fees().gasLimit, kLocalGasLimit);
125
EXPECT_NE(ledger->fees().bytecodeSizeLimit, kLocalBytecodeSizeLimit);
126
EXPECT_NE(ledger->fees().gasPrice, kLocalGasPrice);
127
}
128
129
// The fallback only fills gaps; a present field still governs.
130
TEST_F
(
ExtensionFees
, present_fields_are_taken_from_the_ledger)
131
{
132
constexpr
std::uint32_t
kVotedGasLimit{987'654};
133
constexpr
std::uint32_t
kVotedBytecodeSizeLimit{87'654};
134
constexpr
std::uint32_t
kVotedGasPrice{76'543};
135
136
auto
const
genesis = makeGenesis({featureSmartEscrow});
137
138
auto
const
ledger = successorWithFeeSettings(*genesis, [&](
SLE
& sle) {
139
sle.
at
(sfGasLimit) = kVotedGasLimit;
140
sle.
at
(sfBytecodeSizeLimit) = kVotedBytecodeSizeLimit;
141
sle.
at
(sfGasPrice) = kVotedGasPrice;
142
});
143
144
EXPECT_EQ(ledger->fees().gasLimit, kVotedGasLimit);
145
EXPECT_EQ(ledger->fees().bytecodeSizeLimit, kVotedBytecodeSizeLimit);
146
EXPECT_EQ(ledger->fees().gasPrice, kVotedGasPrice);
147
}
148
149
// An explicit zero is the kill switch, not absence.
150
TEST_F
(
ExtensionFees
, an_explicit_zero_is_not_treated_as_absent)
151
{
152
auto
const
genesis = makeGenesis({featureSmartEscrow});
153
154
auto
const
ledger = successorWithFeeSettings(*genesis, [](
SLE
& sle) {
155
sle.
at
(sfGasLimit) = 0u;
156
sle.
at
(sfBytecodeSizeLimit) = 0u;
157
});
158
159
EXPECT_EQ(ledger->fees().gasLimit, 0u);
160
EXPECT_EQ(ledger->fees().bytecodeSizeLimit, 0u);
161
}
162
163
// FeeSettings may carry the gas settings only once the amendment is enabled.
164
TEST_F
(
ExtensionFees
, gas_settings_before_the_amendment_fail_to_load)
165
{
166
auto
const
genesis = makeGenesis({});
167
168
auto
const
ledger =
169
successorWithFeeSettings(*genesis, [](
SLE
& sle) { sle.
at
(sfGasLimit) =
kDefaultGasLimit
; });
170
171
ASSERT_FALSE(ledger->rules().enabled(featureSmartEscrow));
172
EXPECT_FALSE(reloads(*ledger));
173
}
174
175
TEST_F
(
ExtensionFees
, gas_settings_after_the_amendment_load)
176
{
177
auto
const
genesis = makeGenesis({featureSmartEscrow});
178
179
auto
const
ledger =
180
successorWithFeeSettings(*genesis, [](
SLE
& sle) { sle.
at
(sfGasLimit) =
kDefaultGasLimit
; });
181
182
ASSERT_TRUE(ledger->rules().enabled(featureSmartEscrow));
183
EXPECT_TRUE(reloads(*ledger));
184
}
185
186
}
// namespace xrpl::test
beast::Journal
A generic endpoint for log messages.
Definition
Journal.h:44
beast::Journal::getNullSink
static Sink & getNullSink()
Returns a Sink which does nothing.
Definition
beast_Journal.cpp:63
xrpl::Ledger
Holds a ledger.
Definition
include/xrpl/ledger/Ledger.h:76
xrpl::Ledger::header
LedgerHeader const & header() const override
Returns information about the ledger.
Definition
include/xrpl/ledger/Ledger.h:157
xrpl::NetClock::time_point
std::chrono::time_point< NetClock > time_point
Definition
chrono.h:48
xrpl::Rules
Rules controlling protocol behavior.
Definition
Rules.h:40
xrpl::STObject::at
T::value_type at(TypedField< T > const &f) const
Get the value of a field.
Definition
STObject.h:1077
xrpl::STObject::makeFieldAbsent
void makeFieldAbsent(SField const &field)
Definition
STObject.cpp:550
xrpl::tests::TestNodeFamily
Definition
common.h:27
cstdint
std::uint32_t
std::make_shared
T make_shared(T... args)
memory
xrpl::keylet::feeSettings
Keylet const & feeSettings() noexcept
The (fixed) index of the object containing the ledger fees.
Definition
Indexes.cpp:267
xrpl::test
Definition
STLedgerEntry.h:21
xrpl::test::TEST_F
TEST_F(BaseUintDeathTest, from_raw_size_mismatch)
Definition
base_uint.cpp:73
xrpl::test::XRPAmount
constexpr XRPAmount
Convert XRP to drops (integral types).
Definition
TxTest.h:53
xrpl::kDefaultGasLimit
constexpr std::uint32_t kDefaultGasLimit
Definition
protocol/Fees.h:24
xrpl::kCreateGenesis
CreateGenesisT const kCreateGenesis
Definition
libxrpl/ledger/Ledger.cpp:51
xrpl::NodeObjectType::AccountNode
@ AccountNode
Definition
NodeObject.h:21
xrpl::SLE
STLedgerEntry SLE
Definition
ServiceRegistry.h:42
xrpl::kDefaultGasPrice
constexpr std::uint32_t kDefaultGasPrice
Definition
protocol/Fees.h:26
xrpl::kDefaultBytecodeSizeLimit
constexpr std::uint32_t kDefaultBytecodeSizeLimit
Definition
protocol/Fees.h:25
std::shared_ptr
xrpl::test::ExtensionFees
Definition
ExtensionFees.cpp:48
xrpl::test::ExtensionFees::family
tests::TestNodeFamily family
Definition
ExtensionFees.cpp:50
xrpl::test::ExtensionFees::presets
std::unordered_set< UInt256, beast::Uhash<> > presets
Definition
ExtensionFees.cpp:49
xrpl::test::ExtensionFees::reloads
bool reloads(Ledger const &ledger)
Definition
ExtensionFees.cpp:79
xrpl::test::ExtensionFees::successorWithFeeSettings
std::shared_ptr< Ledger > successorWithFeeSettings(Ledger const &parent, F &&edit)
Definition
ExtensionFees.cpp:65
xrpl::test::ExtensionFees::makeGenesis
std::shared_ptr< Ledger > makeGenesis(std::vector< UInt256 > const &amendments)
Definition
ExtensionFees.cpp:53
unordered_set
vector
Generated by
1.17.0